##// END OF EJS Templates
Ability to cache commits before writing to disk, to save power.
Thomas Kluyver -
Show More
@@ -1,511 +1,528 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 os
17 17 import sqlite3
18 18
19 19 # Our own packages
20 20 import IPython.utils.io
21 21
22 22 from IPython.testing import decorators as testdec
23 from IPython.utils.pickleshare import PickleShareDB
24 23 from IPython.utils.io import ask_yes_no
25 24 from IPython.utils.warn import warn
26 25
27 26 #-----------------------------------------------------------------------------
28 27 # Classes and functions
29 28 #-----------------------------------------------------------------------------
30 29
31 30 class HistoryManager(object):
32 31 """A class to organize all history-related functionality in one place.
33 32 """
34 33 # Public interface
35 34
36 35 # An instance of the IPython shell we are attached to
37 36 shell = None
38 37 # A list to hold processed history
39 38 input_hist_parsed = None
40 39 # A list to hold raw history (as typed by user)
41 40 input_hist_raw = None
42 41 # A list of directories visited during session
43 42 dir_hist = None
44 43 # A dict of output history, keyed with ints from the shell's execution count
45 44 output_hist = None
46 45 # String with path to the history file
47 46 hist_file = None
48 47 # The SQLite database
49 48 db = None
50 49 # The number of the current session in the history database
51 50 session_number = None
51 # Number of lines to cache before writing to the database (to save power)
52 # - if 0, lines will be written instantly.
53 db_cache_size = 0
54 # The line cache
55 db_cache = None
52 56
53 57 # Private interface
54 58 # Variables used to store the three last inputs from the user. On each new
55 59 # history update, we populate the user's namespace with these, shifted as
56 60 # necessary.
57 61 _i00, _i, _ii, _iii = '','','',''
58 62
59 63 # A set with all forms of the exit command, so that we don't store them in
60 64 # the history (it's annoying to rewind the first entry and land on an exit
61 65 # call).
62 66 _exit_commands = None
63 67
64 68 def __init__(self, shell, load_history=False):
65 69 """Create a new history manager associated with a shell instance.
66 70
67 71 Parameters
68 72 ----------
69 73 load_history: bool, optional
70 74 If True, history will be loaded from file, and the session
71 75 offset set, so that the next line entered can be retrieved
72 76 as #1.
73 77 """
74 78 # We need a pointer back to the shell for various tasks.
75 79 self.shell = shell
76 80
77 81 # List of input with multi-line handling. One blank entry so indexing
78 82 # starts from 1.
79 83 self.input_hist_parsed = [""]
80 84 # This one will hold the 'raw' input history, without any
81 85 # pre-processing. This will allow users to retrieve the input just as
82 86 # it was exactly typed in by the user, with %hist -r.
83 87 self.input_hist_raw = [""]
84 88
85 89 # list of visited directories
86 90 try:
87 91 self.dir_hist = [os.getcwd()]
88 92 except OSError:
89 93 self.dir_hist = []
90 94
91 95 # dict of output history
92 96 self.output_hist = {}
93 97
94 98 # Now the history file
95 99 if shell.profile:
96 100 histfname = 'history-%s' % shell.profile
97 101 else:
98 102 histfname = 'history'
99 103 self.hist_file = os.path.join(shell.ipython_dir, histfname + '.sqlite')
100 104
101 105 self._i00, self._i, self._ii, self._iii = '','','',''
102 106
103 107 self._exit_commands = set(['Quit', 'quit', 'Exit', 'exit', '%Quit',
104 108 '%quit', '%Exit', '%exit'])
105 109
106 110 self.init_db()
107 111
108 112 def init_db(self):
109 113 self.db = sqlite3.connect(self.hist_file)
110 114 self.db.execute("""CREATE TABLE IF NOT EXISTS history (session integer,
111 115 line integer, source text, source_raw text,
112 116 PRIMARY KEY (session, line))""")
113 117 cur = self.db.execute("""SELECT name FROM sqlite_master WHERE
114 118 type='table' AND name='singletons'""")
115 119 if not cur.fetchone():
116 120 self.db.execute("""CREATE TABLE singletons
117 121 (name text PRIMARY KEY, value)""")
118 122 self.db.execute("""INSERT INTO singletons VALUES
119 123 ('session_number', 1)""")
120 124 self.db.commit()
121 125 cur = self.db.execute("""SELECT value FROM singletons WHERE
122 126 name='session_number'""")
123 127 self.session_number = cur.fetchone()[0]
124 128
125 129 #Increment by one for next session.
126 130 self.db.execute("""UPDATE singletons SET value=? WHERE
127 131 name='session_number'""", (self.session_number+1,))
128 132 self.db.commit()
133 self.db_cache = []
129 134
130 135 def get_db_history(self, session, start=1, stop=None, raw=True):
131 136 """Retrieve input history from the database by session.
132 137
133 138 Parameters
134 139 ----------
135 140 session : int
136 141 Session number to retrieve. If negative, counts back from current
137 142 session (so -1 is previous session).
138 143 start : int
139 144 First line to retrieve.
140 145 stop : int
141 146 Last line to retrieve. If None, retrieve to the end of the session.
142 147 raw : bool
143 148 If True, return raw input
144 149
145 150 Returns
146 151 -------
147 152 An iterator over the desired lines.
148 153 """
149 154 toget = 'source_raw' if raw else 'source'
150 155 if session < 0:
151 156 session += self.session_number
152 157
153 158 if stop:
154 159 cur = self.db.execute("SELECT " + toget + """ FROM history WHERE
155 160 session==? AND line BETWEEN ? and ?""",
156 161 (session, start, stop))
157 162 else:
158 163 cur = self.db.execute("SELECT " + toget + """ FROM history WHERE
159 164 session==? AND line>=?""", (session, start))
160 165 return (x[0] for x in cur)
161 166
162 167 def tail_db_history(self, n=10, raw=True):
163 168 """Get the last n lines from the history database."""
164 169 toget = 'source_raw' if raw else 'source'
165 170 cur = self.db.execute("SELECT " + toget + """ FROM history ORDER BY
166 171 session DESC, line DESC LIMIT ?""", (n,))
167 172 return (x[0] for x in reversed(cur.fetchall()))
168 173
169 174 def globsearch_db(self, pattern="*"):
170 175 """Search the database using unix glob-style matching (wildcards * and
171 176 ?, escape using \).
172 177
173 178 Returns
174 179 -------
175 180 An iterator over tuples: (session, line_number, command)
176 181 """
177 182 return self.db.execute("""SELECT session, line, source_raw FROM history
178 183 WHERE source_raw GLOB ?""", (pattern,))
179 184
180 185 def get_history(self, start=1, stop=None, raw=False, output=True):
181 186 """Get the history list.
182 187
183 188 Get the input and output history.
184 189
185 190 Parameters
186 191 ----------
187 192 start : int
188 193 From (prompt number in the current session). Negative numbers count
189 194 back from the end.
190 195 stop : int
191 196 To (prompt number in the current session, exclusive). Negative
192 197 numbers count back from the end, and None goes to the end.
193 198 raw : bool
194 199 If True, return the raw input.
195 200 output : bool
196 201 If True, then return the output as well.
197 202 this_session : bool
198 203 If True, indexing is from 1 at the start of this session.
199 204 If False, indexing is from 1 at the start of the whole history.
200 205
201 206 Returns
202 207 -------
203 208 If output is True, then return a dict of tuples, keyed by the prompt
204 209 numbers and with values of (input, output). If output is False, then
205 210 a dict, keyed by the prompt number with the values of input.
206 211 """
207 212 if raw:
208 213 input_hist = self.input_hist_raw
209 214 else:
210 215 input_hist = self.input_hist_parsed
211 216 if output:
212 217 output_hist = self.output_hist
213 218
214 219 n = len(input_hist)
215 220 if start < 0:
216 221 start += n
217 222 if not stop:
218 223 stop = n
219 224 elif stop < 0:
220 225 stop += n
221 226
222 227 hist = {}
223 228 for i in range(start, stop):
224 229 if output:
225 230 hist[i] = (input_hist[i], output_hist.get(i))
226 231 else:
227 232 hist[i] = input_hist[i]
228 233 return hist
229 234
230 235 def store_inputs(self, source, source_raw=None):
231 236 """Store source and raw input in history and create input cache
232 237 variables _i*.
233 238
234 239 Parameters
235 240 ----------
236 241 source : str
237 242 Python input.
238 243
239 244 source_raw : str, optional
240 245 If given, this is the raw input without any IPython transformations
241 246 applied to it. If not given, ``source`` is used.
242 247 """
243 248 if source_raw is None:
244 249 source_raw = source
245 250
246 251 # do not store exit/quit commands
247 252 if source_raw.strip() in self._exit_commands:
248 253 return
249 254
250 255 self.input_hist_parsed.append(source.rstrip())
251 256 self.input_hist_raw.append(source_raw.rstrip())
252 with self.db:
253 self.db.execute("INSERT INTO history VALUES (?, ?, ?, ?)",
257 if self.db_cache_size:
258 self.db_cache.append((self.session_number,
259 self.shell.execution_count, source, source_raw))
260 if len(self.db_cache) > self.db_cache_size:
261 self.writeout_cache()
262 else: # Instant write
263 with self.db:
264 self.db.execute("INSERT INTO history VALUES (?, ?, ?, ?)",
254 265 (self.session_number, self.shell.execution_count,
255 266 source, source_raw))
256 267
257 268 # update the auto _i variables
258 269 self._iii = self._ii
259 270 self._ii = self._i
260 271 self._i = self._i00
261 272 self._i00 = source_raw
262 273
263 274 # hackish access to user namespace to create _i1,_i2... dynamically
264 275 new_i = '_i%s' % self.shell.execution_count
265 276 to_main = {'_i': self._i,
266 277 '_ii': self._ii,
267 278 '_iii': self._iii,
268 279 new_i : self._i00 }
269 280 self.shell.user_ns.update(to_main)
281
282 def writeout_cache(self):
283 with self.db:
284 self.db.executemany("INSERT INTO history VALUES (?, ?, ?, ?)",
285 self.db_cache)
286 self.db_cache = []
270 287
271 288 def sync_inputs(self):
272 289 """Ensure raw and translated histories have same length."""
273 290 lr = len(self.input_hist_raw)
274 291 lp = len(self.input_hist_parsed)
275 292 if lp < lr:
276 293 self.input_hist_raw[:lr-lp] = []
277 294 elif lr < lp:
278 295 self.input_hist_parsed[:lp-lr] = []
279 296
280 297 def reset(self):
281 298 """Clear all histories managed by this object."""
282 299 self.input_hist_parsed[:] = []
283 300 self.input_hist_raw[:] = []
284 301 self.output_hist.clear()
285 302 # The directory history can't be completely empty
286 303 self.dir_hist[:] = [os.getcwd()]
287 304
288 305 @testdec.skip_doctest
289 306 def magic_history(self, parameter_s = ''):
290 307 """Print input history (_i<n> variables), with most recent last.
291 308
292 309 %history -> print at most 40 inputs (some may be multi-line)\\
293 310 %history n -> print at most n inputs\\
294 311 %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
295 312
296 313 By default, input history is printed without line numbers so it can be
297 314 directly pasted into an editor.
298 315
299 316 With -n, each input's number <n> is shown, and is accessible as the
300 317 automatically generated variable _i<n> as well as In[<n>]. Multi-line
301 318 statements are printed starting at a new line for easy copy/paste.
302 319
303 320 Options:
304 321
305 322 -n: print line numbers for each input.
306 323 This feature is only available if numbered prompts are in use.
307 324
308 325 -o: also print outputs for each input.
309 326
310 327 -p: print classic '>>>' python prompts before each input. This is useful
311 328 for making documentation, and in conjunction with -o, for producing
312 329 doctest-ready output.
313 330
314 331 -r: (default) print the 'raw' history, i.e. the actual commands you typed.
315 332
316 333 -t: print the 'translated' history, as IPython understands it. IPython
317 334 filters your input and converts it all into valid Python source before
318 335 executing it (things like magics or aliases are turned into function
319 336 calls, for example). With this option, you'll see the native history
320 337 instead of the user-entered version: '%cd /' will be seen as
321 338 'get_ipython().magic("%cd /")' instead of '%cd /'.
322 339
323 340 -g: treat the arg as a pattern to grep for in (full) history.
324 341 This includes the saved history (almost all commands ever written).
325 342 Use '%hist -g' to show full saved history (may be very long).
326 343
327 344 -f FILENAME: instead of printing the output to the screen, redirect it to
328 345 the given file. The file is always overwritten, though IPython asks for
329 346 confirmation first if it already exists.
330 347
331 348 Examples
332 349 --------
333 350 ::
334 351
335 352 In [6]: %hist -n 4 6
336 353 4:a = 12
337 354 5:print a**2
338 355
339 356 """
340 357
341 358 if not self.shell.displayhook.do_full_cache:
342 359 print('This feature is only available if numbered prompts are in use.')
343 360 return
344 361 opts,args = self.parse_options(parameter_s,'gnoptsrf:',mode='list')
345 362
346 363 # For brevity
347 364 history_manager = self.shell.history_manager
348 365
349 366 # Check if output to specific file was requested.
350 367 try:
351 368 outfname = opts['f']
352 369 except KeyError:
353 370 outfile = IPython.utils.io.Term.cout # default
354 371 # We don't want to close stdout at the end!
355 372 close_at_end = False
356 373 else:
357 374 if os.path.exists(outfname):
358 375 if not ask_yes_no("File %r exists. Overwrite?" % outfname):
359 376 print('Aborting.')
360 377 return
361 378
362 379 outfile = open(outfname,'w')
363 380 close_at_end = True
364 381
365 382 print_nums = 'n' in opts
366 383 print_outputs = 'o' in opts
367 384 pyprompts = 'p' in opts
368 385 # Raw history is the default
369 386 raw = not('t' in opts)
370 387
371 388 default_length = 40
372 389 pattern = None
373 390 if 'g' in opts:
374 391 start = 1; stop = None
375 392 parts = parameter_s.split(None, 1)
376 393 if len(parts) == 1:
377 394 parts += '*'
378 395 head, pattern = parts
379 396 pattern = "*" + pattern + "*"
380 397 elif len(args) == 0:
381 398 start = 1; stop = None
382 399 elif len(args) == 1:
383 400 start = -int(args[0]); stop=None
384 401 elif len(args) == 2:
385 402 start = int(args[0]); stop = int(args[1])
386 403 else:
387 404 warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
388 405 print(self.magic_hist.__doc__, file=IPython.utils.io.Term.cout)
389 406 return
390 407
391 408 hist = history_manager.get_history(start, stop, raw, print_outputs)
392 409
393 410 width = len(str(max(hist.iterkeys())))
394 411 line_sep = ['','\n']
395 412
396 413 found = False
397 414 if pattern is not None:
398 415 for session, line, s in history_manager.globsearch_db(pattern):
399 416 print("%d#%d: %s" %(session, line, s.expandtabs(4)), file=outfile)
400 417 found = True
401 418
402 419 if found:
403 420 print("===", file=outfile)
404 421 print("shadow history ends, fetch by %rep session#line",
405 422 file=outfile)
406 423 print("=== start of normal history ===", file=outfile)
407 424
408 425 for in_num, inline in sorted(hist.iteritems()):
409 426 # Print user history with tabs expanded to 4 spaces. The GUI clients
410 427 # use hard tabs for easier usability in auto-indented code, but we want
411 428 # to produce PEP-8 compliant history for safe pasting into an editor.
412 429 if print_outputs:
413 430 inline, output = inline
414 431 inline = inline.expandtabs(4).rstrip()
415 432
416 433 if pattern is not None and not fnmatch.fnmatch(inline, pattern):
417 434 continue
418 435
419 436 multiline = "\n" in inline
420 437 if print_nums:
421 438 print('%s:%s' % (str(in_num).ljust(width), line_sep[multiline]),
422 439 file=outfile, end='')
423 440 if pyprompts:
424 441 print(">>> ", end="", file=outfile)
425 442 if multiline:
426 443 inline = "\n... ".join(inline.splitlines()) + "\n..."
427 444 print(inline, file=outfile)
428 445 if print_outputs and output:
429 446 print(repr(output), file=outfile)
430 447
431 448 if close_at_end:
432 449 outfile.close()
433 450
434 451 # %hist is an alternative name
435 452 magic_hist = magic_history
436 453
437 454
438 455 def rep_f(self, arg):
439 456 r""" Repeat a command, or get command to input line for editing
440 457
441 458 - %rep (no arguments):
442 459
443 460 Place a string version of last computation result (stored in the special '_'
444 461 variable) to the next input prompt. Allows you to create elaborate command
445 462 lines without using copy-paste::
446 463
447 464 $ l = ["hei", "vaan"]
448 465 $ "".join(l)
449 466 ==> heivaan
450 467 $ %rep
451 468 $ heivaan_ <== cursor blinking
452 469
453 470 %rep 45
454 471
455 472 Place history line 45 to next input prompt. Use %hist to find out the
456 473 number.
457 474
458 475 %rep 1-4 6-7 3
459 476
460 477 Repeat the specified lines immediately. Input slice syntax is the same as
461 478 in %macro and %save.
462 479
463 480 %rep foo
464 481
465 482 Place the most recent line that has the substring "foo" to next input.
466 483 (e.g. 'svn ci -m foobar').
467 484 """
468 485
469 486 opts,args = self.parse_options(arg,'',mode='list')
470 487 if not args:
471 488 self.set_next_input(str(self.shell.user_ns["_"]))
472 489 return
473 490
474 491 if len(args) == 1 and not '-' in args[0]:
475 492 arg = args[0]
476 493 if len(arg) > 1 and arg.startswith('0'):
477 494 # get from shadow hist
478 495 num = int(arg[1:])
479 496 line = self.shell.shadowhist.get(num)
480 497 self.set_next_input(str(line))
481 498 return
482 499 try:
483 500 num = int(args[0])
484 501 self.set_next_input(str(self.shell.input_hist_raw[num]).rstrip())
485 502 return
486 503 except ValueError:
487 504 pass
488 505
489 506 for h in reversed(self.shell.input_hist_raw):
490 507 if 'rep' in h:
491 508 continue
492 509 if fnmatch.fnmatch(h,'*' + arg + '*'):
493 510 self.set_next_input(str(h).rstrip())
494 511 return
495 512
496 513 try:
497 514 lines = self.extract_input_slices(args, True)
498 515 print("lines", lines)
499 516 self.run_cell(lines)
500 517 except ValueError:
501 518 print("Not found in recent history:", args)
502 519
503 520
504 521 def init_ipython(ip):
505 522 ip.define_magic("rep",rep_f)
506 523 ip.define_magic("hist",magic_hist)
507 524 ip.define_magic("history",magic_history)
508 525
509 526 # XXX - ipy_completers are in quarantine, need to be updated to new apis
510 527 #import ipy_completers
511 528 #ipy_completers.quick_completer('%hist' ,'-g -t -r -n')
@@ -1,2546 +1,2549 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Main IPython class."""
3 3
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 7 # Copyright (C) 2008-2011 The IPython Development Team
8 8 #
9 9 # Distributed under the terms of the BSD License. The full license is in
10 10 # the file COPYING, distributed as part of this software.
11 11 #-----------------------------------------------------------------------------
12 12
13 13 #-----------------------------------------------------------------------------
14 14 # Imports
15 15 #-----------------------------------------------------------------------------
16 16
17 17 from __future__ import with_statement
18 18 from __future__ import absolute_import
19 19
20 20 import __builtin__
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.displaypub import DisplayPublisher
45 45 from IPython.core.error import TryNext, UsageError
46 46 from IPython.core.extensions import ExtensionManager
47 47 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
48 48 from IPython.core.formatters import DisplayFormatter
49 49 from IPython.core.history import HistoryManager
50 50 from IPython.core.inputsplitter import IPythonInputSplitter
51 51 from IPython.core.logger import Logger
52 52 from IPython.core.magic import Magic
53 53 from IPython.core.payload import PayloadManager
54 54 from IPython.core.plugin import PluginManager
55 55 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
56 56 from IPython.external.Itpl import ItplNS
57 57 from IPython.utils import PyColorize
58 58 from IPython.utils import io
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.pickleshare import PickleShareDB
64 64 from IPython.utils.process import system, getoutput
65 65 from IPython.utils.strdispatch import StrDispatch
66 66 from IPython.utils.syspathcontext import prepended_to_syspath
67 67 from IPython.utils.text import num_ini_spaces, format_screen, LSString, SList
68 68 from IPython.utils.traitlets import (Int, Str, CBool, CaselessStrEnum, Enum,
69 69 List, Unicode, Instance, Type)
70 70 from IPython.utils.warn import warn, error, fatal
71 71 import IPython.core.hooks
72 72
73 73 #-----------------------------------------------------------------------------
74 74 # Globals
75 75 #-----------------------------------------------------------------------------
76 76
77 77 # compiled regexps for autoindent management
78 78 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
79 79
80 80 #-----------------------------------------------------------------------------
81 81 # Utilities
82 82 #-----------------------------------------------------------------------------
83 83
84 84 # store the builtin raw_input globally, and use this always, in case user code
85 85 # overwrites it (like wx.py.PyShell does)
86 86 raw_input_original = raw_input
87 87
88 88 def softspace(file, newvalue):
89 89 """Copied from code.py, to remove the dependency"""
90 90
91 91 oldvalue = 0
92 92 try:
93 93 oldvalue = file.softspace
94 94 except AttributeError:
95 95 pass
96 96 try:
97 97 file.softspace = newvalue
98 98 except (AttributeError, TypeError):
99 99 # "attribute-less object" or "read-only attributes"
100 100 pass
101 101 return oldvalue
102 102
103 103
104 104 def no_op(*a, **kw): pass
105 105
106 106 class SpaceInInput(Exception): pass
107 107
108 108 class Bunch: pass
109 109
110 110
111 111 def get_default_colors():
112 112 if sys.platform=='darwin':
113 113 return "LightBG"
114 114 elif os.name=='nt':
115 115 return 'Linux'
116 116 else:
117 117 return 'Linux'
118 118
119 119
120 120 class SeparateStr(Str):
121 121 """A Str subclass to validate separate_in, separate_out, etc.
122 122
123 123 This is a Str based trait that converts '0'->'' and '\\n'->'\n'.
124 124 """
125 125
126 126 def validate(self, obj, value):
127 127 if value == '0': value = ''
128 128 value = value.replace('\\n','\n')
129 129 return super(SeparateStr, self).validate(obj, value)
130 130
131 131 class MultipleInstanceError(Exception):
132 132 pass
133 133
134 134
135 135 #-----------------------------------------------------------------------------
136 136 # Main IPython class
137 137 #-----------------------------------------------------------------------------
138 138
139 139 class InteractiveShell(Configurable, Magic):
140 140 """An enhanced, interactive shell for Python."""
141 141
142 142 _instance = None
143 143 autocall = Enum((0,1,2), default_value=1, config=True)
144 144 # TODO: remove all autoindent logic and put into frontends.
145 145 # We can't do this yet because even runlines uses the autoindent.
146 146 autoindent = CBool(True, config=True)
147 147 automagic = CBool(True, config=True)
148 148 cache_size = Int(1000, config=True)
149 149 color_info = CBool(True, config=True)
150 150 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
151 151 default_value=get_default_colors(), config=True)
152 152 debug = CBool(False, config=True)
153 153 deep_reload = CBool(False, config=True)
154 154 display_formatter = Instance(DisplayFormatter)
155 155 displayhook_class = Type(DisplayHook)
156 156 display_pub_class = Type(DisplayPublisher)
157 157
158 158 exit_now = CBool(False)
159 159 # Monotonically increasing execution counter
160 160 execution_count = Int(1)
161 161 filename = Str("<ipython console>")
162 162 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
163 163
164 164 # Input splitter, to split entire cells of input into either individual
165 165 # interactive statements or whole blocks.
166 166 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
167 167 (), {})
168 168 logstart = CBool(False, config=True)
169 169 logfile = Str('', config=True)
170 170 logappend = Str('', config=True)
171 171 object_info_string_level = Enum((0,1,2), default_value=0,
172 172 config=True)
173 173 pdb = CBool(False, config=True)
174 174
175 175 profile = Str('', config=True)
176 176 prompt_in1 = Str('In [\\#]: ', config=True)
177 177 prompt_in2 = Str(' .\\D.: ', config=True)
178 178 prompt_out = Str('Out[\\#]: ', config=True)
179 179 prompts_pad_left = CBool(True, config=True)
180 180 quiet = CBool(False, config=True)
181 181
182 182 history_length = Int(10000, config=True)
183 183
184 184 # The readline stuff will eventually be moved to the terminal subclass
185 185 # but for now, we can't do that as readline is welded in everywhere.
186 186 readline_use = CBool(True, config=True)
187 187 readline_merge_completions = CBool(True, config=True)
188 188 readline_omit__names = Enum((0,1,2), default_value=2, config=True)
189 189 readline_remove_delims = Str('-/~', config=True)
190 190 readline_parse_and_bind = List([
191 191 'tab: complete',
192 192 '"\C-l": clear-screen',
193 193 'set show-all-if-ambiguous on',
194 194 '"\C-o": tab-insert',
195 195 '"\M-i": " "',
196 196 '"\M-o": "\d\d\d\d"',
197 197 '"\M-I": "\d\d\d\d"',
198 198 '"\C-r": reverse-search-history',
199 199 '"\C-s": forward-search-history',
200 200 '"\C-p": history-search-backward',
201 201 '"\C-n": history-search-forward',
202 202 '"\e[A": history-search-backward',
203 203 '"\e[B": history-search-forward',
204 204 '"\C-k": kill-line',
205 205 '"\C-u": unix-line-discard',
206 206 ], allow_none=False, config=True)
207 207
208 208 # TODO: this part of prompt management should be moved to the frontends.
209 209 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
210 210 separate_in = SeparateStr('\n', config=True)
211 211 separate_out = SeparateStr('', config=True)
212 212 separate_out2 = SeparateStr('', config=True)
213 213 wildcards_case_sensitive = CBool(True, config=True)
214 214 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
215 215 default_value='Context', config=True)
216 216
217 217 # Subcomponents of InteractiveShell
218 218 alias_manager = Instance('IPython.core.alias.AliasManager')
219 219 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
220 220 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
221 221 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
222 222 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
223 223 plugin_manager = Instance('IPython.core.plugin.PluginManager')
224 224 payload_manager = Instance('IPython.core.payload.PayloadManager')
225 225 history_manager = Instance('IPython.core.history.HistoryManager')
226 226
227 227 # Private interface
228 228 _post_execute = set()
229 229
230 230 def __init__(self, config=None, ipython_dir=None,
231 231 user_ns=None, user_global_ns=None,
232 232 custom_exceptions=((), None)):
233 233
234 234 # This is where traits with a config_key argument are updated
235 235 # from the values on config.
236 236 super(InteractiveShell, self).__init__(config=config)
237 237
238 238 # These are relatively independent and stateless
239 239 self.init_ipython_dir(ipython_dir)
240 240 self.init_instance_attrs()
241 241 self.init_environment()
242 242
243 243 # Create namespaces (user_ns, user_global_ns, etc.)
244 244 self.init_create_namespaces(user_ns, user_global_ns)
245 245 # This has to be done after init_create_namespaces because it uses
246 246 # something in self.user_ns, but before init_sys_modules, which
247 247 # is the first thing to modify sys.
248 248 # TODO: When we override sys.stdout and sys.stderr before this class
249 249 # is created, we are saving the overridden ones here. Not sure if this
250 250 # is what we want to do.
251 251 self.save_sys_module_state()
252 252 self.init_sys_modules()
253 253
254 254 # While we're trying to have each part of the code directly access what
255 255 # it needs without keeping redundant references to objects, we have too
256 256 # much legacy code that expects ip.db to exist.
257 257 self.db = PickleShareDB(os.path.join(self.ipython_dir, 'db'))
258 258
259 259 self.init_history()
260 260 self.init_encoding()
261 261 self.init_prefilter()
262 262
263 263 Magic.__init__(self, self)
264 264
265 265 self.init_syntax_highlighting()
266 266 self.init_hooks()
267 267 self.init_pushd_popd_magic()
268 268 # self.init_traceback_handlers use to be here, but we moved it below
269 269 # because it and init_io have to come after init_readline.
270 270 self.init_user_ns()
271 271 self.init_logger()
272 272 self.init_alias()
273 273 self.init_builtins()
274 274
275 275 # pre_config_initialization
276 276
277 277 # The next section should contain everything that was in ipmaker.
278 278 self.init_logstart()
279 279
280 280 # The following was in post_config_initialization
281 281 self.init_inspector()
282 282 # init_readline() must come before init_io(), because init_io uses
283 283 # readline related things.
284 284 self.init_readline()
285 285 # init_completer must come after init_readline, because it needs to
286 286 # know whether readline is present or not system-wide to configure the
287 287 # completers, since the completion machinery can now operate
288 288 # independently of readline (e.g. over the network)
289 289 self.init_completer()
290 290 # TODO: init_io() needs to happen before init_traceback handlers
291 291 # because the traceback handlers hardcode the stdout/stderr streams.
292 292 # This logic in in debugger.Pdb and should eventually be changed.
293 293 self.init_io()
294 294 self.init_traceback_handlers(custom_exceptions)
295 295 self.init_prompts()
296 296 self.init_display_formatter()
297 297 self.init_display_pub()
298 298 self.init_displayhook()
299 299 self.init_reload_doctest()
300 300 self.init_magics()
301 301 self.init_pdb()
302 302 self.init_extension_manager()
303 303 self.init_plugin_manager()
304 304 self.init_payload()
305 305 self.hooks.late_startup_hook()
306 306 atexit.register(self.atexit_operations)
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_display_formatter(self):
488 488 self.display_formatter = DisplayFormatter(config=self.config)
489 489
490 490 def init_display_pub(self):
491 491 self.display_pub = self.display_pub_class(config=self.config)
492 492
493 493 def init_displayhook(self):
494 494 # Initialize displayhook, set in/out prompts and printing system
495 495 self.displayhook = self.displayhook_class(
496 496 config=self.config,
497 497 shell=self,
498 498 cache_size=self.cache_size,
499 499 input_sep = self.separate_in,
500 500 output_sep = self.separate_out,
501 501 output_sep2 = self.separate_out2,
502 502 ps1 = self.prompt_in1,
503 503 ps2 = self.prompt_in2,
504 504 ps_out = self.prompt_out,
505 505 pad_left = self.prompts_pad_left
506 506 )
507 507 # This is a context manager that installs/revmoes the displayhook at
508 508 # the appropriate time.
509 509 self.display_trap = DisplayTrap(hook=self.displayhook)
510 510
511 511 def init_reload_doctest(self):
512 512 # Do a proper resetting of doctest, including the necessary displayhook
513 513 # monkeypatching
514 514 try:
515 515 doctest_reload()
516 516 except ImportError:
517 517 warn("doctest module does not exist.")
518 518
519 519 #-------------------------------------------------------------------------
520 520 # Things related to injections into the sys module
521 521 #-------------------------------------------------------------------------
522 522
523 523 def save_sys_module_state(self):
524 524 """Save the state of hooks in the sys module.
525 525
526 526 This has to be called after self.user_ns is created.
527 527 """
528 528 self._orig_sys_module_state = {}
529 529 self._orig_sys_module_state['stdin'] = sys.stdin
530 530 self._orig_sys_module_state['stdout'] = sys.stdout
531 531 self._orig_sys_module_state['stderr'] = sys.stderr
532 532 self._orig_sys_module_state['excepthook'] = sys.excepthook
533 533 try:
534 534 self._orig_sys_modules_main_name = self.user_ns['__name__']
535 535 except KeyError:
536 536 pass
537 537
538 538 def restore_sys_module_state(self):
539 539 """Restore the state of the sys module."""
540 540 try:
541 541 for k, v in self._orig_sys_module_state.iteritems():
542 542 setattr(sys, k, v)
543 543 except AttributeError:
544 544 pass
545 545 # Reset what what done in self.init_sys_modules
546 546 try:
547 547 sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
548 548 except (AttributeError, KeyError):
549 549 pass
550 550
551 551 #-------------------------------------------------------------------------
552 552 # Things related to hooks
553 553 #-------------------------------------------------------------------------
554 554
555 555 def init_hooks(self):
556 556 # hooks holds pointers used for user-side customizations
557 557 self.hooks = Struct()
558 558
559 559 self.strdispatchers = {}
560 560
561 561 # Set all default hooks, defined in the IPython.hooks module.
562 562 hooks = IPython.core.hooks
563 563 for hook_name in hooks.__all__:
564 564 # default hooks have priority 100, i.e. low; user hooks should have
565 565 # 0-100 priority
566 566 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
567 567
568 568 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
569 569 """set_hook(name,hook) -> sets an internal IPython hook.
570 570
571 571 IPython exposes some of its internal API as user-modifiable hooks. By
572 572 adding your function to one of these hooks, you can modify IPython's
573 573 behavior to call at runtime your own routines."""
574 574
575 575 # At some point in the future, this should validate the hook before it
576 576 # accepts it. Probably at least check that the hook takes the number
577 577 # of args it's supposed to.
578 578
579 579 f = types.MethodType(hook,self)
580 580
581 581 # check if the hook is for strdispatcher first
582 582 if str_key is not None:
583 583 sdp = self.strdispatchers.get(name, StrDispatch())
584 584 sdp.add_s(str_key, f, priority )
585 585 self.strdispatchers[name] = sdp
586 586 return
587 587 if re_key is not None:
588 588 sdp = self.strdispatchers.get(name, StrDispatch())
589 589 sdp.add_re(re.compile(re_key), f, priority )
590 590 self.strdispatchers[name] = sdp
591 591 return
592 592
593 593 dp = getattr(self.hooks, name, None)
594 594 if name not in IPython.core.hooks.__all__:
595 595 print "Warning! Hook '%s' is not one of %s" % \
596 596 (name, IPython.core.hooks.__all__ )
597 597 if not dp:
598 598 dp = IPython.core.hooks.CommandChainDispatcher()
599 599
600 600 try:
601 601 dp.add(f,priority)
602 602 except AttributeError:
603 603 # it was not commandchain, plain old func - replace
604 604 dp = f
605 605
606 606 setattr(self.hooks,name, dp)
607 607
608 608 def register_post_execute(self, func):
609 609 """Register a function for calling after code execution.
610 610 """
611 611 if not callable(func):
612 612 raise ValueError('argument %s must be callable' % func)
613 613 self._post_execute.add(func)
614 614
615 615 #-------------------------------------------------------------------------
616 616 # Things related to the "main" module
617 617 #-------------------------------------------------------------------------
618 618
619 619 def new_main_mod(self,ns=None):
620 620 """Return a new 'main' module object for user code execution.
621 621 """
622 622 main_mod = self._user_main_module
623 623 init_fakemod_dict(main_mod,ns)
624 624 return main_mod
625 625
626 626 def cache_main_mod(self,ns,fname):
627 627 """Cache a main module's namespace.
628 628
629 629 When scripts are executed via %run, we must keep a reference to the
630 630 namespace of their __main__ module (a FakeModule instance) around so
631 631 that Python doesn't clear it, rendering objects defined therein
632 632 useless.
633 633
634 634 This method keeps said reference in a private dict, keyed by the
635 635 absolute path of the module object (which corresponds to the script
636 636 path). This way, for multiple executions of the same script we only
637 637 keep one copy of the namespace (the last one), thus preventing memory
638 638 leaks from old references while allowing the objects from the last
639 639 execution to be accessible.
640 640
641 641 Note: we can not allow the actual FakeModule instances to be deleted,
642 642 because of how Python tears down modules (it hard-sets all their
643 643 references to None without regard for reference counts). This method
644 644 must therefore make a *copy* of the given namespace, to allow the
645 645 original module's __dict__ to be cleared and reused.
646 646
647 647
648 648 Parameters
649 649 ----------
650 650 ns : a namespace (a dict, typically)
651 651
652 652 fname : str
653 653 Filename associated with the namespace.
654 654
655 655 Examples
656 656 --------
657 657
658 658 In [10]: import IPython
659 659
660 660 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
661 661
662 662 In [12]: IPython.__file__ in _ip._main_ns_cache
663 663 Out[12]: True
664 664 """
665 665 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
666 666
667 667 def clear_main_mod_cache(self):
668 668 """Clear the cache of main modules.
669 669
670 670 Mainly for use by utilities like %reset.
671 671
672 672 Examples
673 673 --------
674 674
675 675 In [15]: import IPython
676 676
677 677 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
678 678
679 679 In [17]: len(_ip._main_ns_cache) > 0
680 680 Out[17]: True
681 681
682 682 In [18]: _ip.clear_main_mod_cache()
683 683
684 684 In [19]: len(_ip._main_ns_cache) == 0
685 685 Out[19]: True
686 686 """
687 687 self._main_ns_cache.clear()
688 688
689 689 #-------------------------------------------------------------------------
690 690 # Things related to debugging
691 691 #-------------------------------------------------------------------------
692 692
693 693 def init_pdb(self):
694 694 # Set calling of pdb on exceptions
695 695 # self.call_pdb is a property
696 696 self.call_pdb = self.pdb
697 697
698 698 def _get_call_pdb(self):
699 699 return self._call_pdb
700 700
701 701 def _set_call_pdb(self,val):
702 702
703 703 if val not in (0,1,False,True):
704 704 raise ValueError,'new call_pdb value must be boolean'
705 705
706 706 # store value in instance
707 707 self._call_pdb = val
708 708
709 709 # notify the actual exception handlers
710 710 self.InteractiveTB.call_pdb = val
711 711
712 712 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
713 713 'Control auto-activation of pdb at exceptions')
714 714
715 715 def debugger(self,force=False):
716 716 """Call the pydb/pdb debugger.
717 717
718 718 Keywords:
719 719
720 720 - force(False): by default, this routine checks the instance call_pdb
721 721 flag and does not actually invoke the debugger if the flag is false.
722 722 The 'force' option forces the debugger to activate even if the flag
723 723 is false.
724 724 """
725 725
726 726 if not (force or self.call_pdb):
727 727 return
728 728
729 729 if not hasattr(sys,'last_traceback'):
730 730 error('No traceback has been produced, nothing to debug.')
731 731 return
732 732
733 733 # use pydb if available
734 734 if debugger.has_pydb:
735 735 from pydb import pm
736 736 else:
737 737 # fallback to our internal debugger
738 738 pm = lambda : self.InteractiveTB.debugger(force=True)
739 739 self.history_saving_wrapper(pm)()
740 740
741 741 #-------------------------------------------------------------------------
742 742 # Things related to IPython's various namespaces
743 743 #-------------------------------------------------------------------------
744 744
745 745 def init_create_namespaces(self, user_ns=None, user_global_ns=None):
746 746 # Create the namespace where the user will operate. user_ns is
747 747 # normally the only one used, and it is passed to the exec calls as
748 748 # the locals argument. But we do carry a user_global_ns namespace
749 749 # given as the exec 'globals' argument, This is useful in embedding
750 750 # situations where the ipython shell opens in a context where the
751 751 # distinction between locals and globals is meaningful. For
752 752 # non-embedded contexts, it is just the same object as the user_ns dict.
753 753
754 754 # FIXME. For some strange reason, __builtins__ is showing up at user
755 755 # level as a dict instead of a module. This is a manual fix, but I
756 756 # should really track down where the problem is coming from. Alex
757 757 # Schmolck reported this problem first.
758 758
759 759 # A useful post by Alex Martelli on this topic:
760 760 # Re: inconsistent value from __builtins__
761 761 # Von: Alex Martelli <aleaxit@yahoo.com>
762 762 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
763 763 # Gruppen: comp.lang.python
764 764
765 765 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
766 766 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
767 767 # > <type 'dict'>
768 768 # > >>> print type(__builtins__)
769 769 # > <type 'module'>
770 770 # > Is this difference in return value intentional?
771 771
772 772 # Well, it's documented that '__builtins__' can be either a dictionary
773 773 # or a module, and it's been that way for a long time. Whether it's
774 774 # intentional (or sensible), I don't know. In any case, the idea is
775 775 # that if you need to access the built-in namespace directly, you
776 776 # should start with "import __builtin__" (note, no 's') which will
777 777 # definitely give you a module. Yeah, it's somewhat confusing:-(.
778 778
779 779 # These routines return properly built dicts as needed by the rest of
780 780 # the code, and can also be used by extension writers to generate
781 781 # properly initialized namespaces.
782 782 user_ns, user_global_ns = self.make_user_namespaces(user_ns,
783 783 user_global_ns)
784 784
785 785 # Assign namespaces
786 786 # This is the namespace where all normal user variables live
787 787 self.user_ns = user_ns
788 788 self.user_global_ns = user_global_ns
789 789
790 790 # An auxiliary namespace that checks what parts of the user_ns were
791 791 # loaded at startup, so we can list later only variables defined in
792 792 # actual interactive use. Since it is always a subset of user_ns, it
793 793 # doesn't need to be separately tracked in the ns_table.
794 794 self.user_ns_hidden = {}
795 795
796 796 # A namespace to keep track of internal data structures to prevent
797 797 # them from cluttering user-visible stuff. Will be updated later
798 798 self.internal_ns = {}
799 799
800 800 # Now that FakeModule produces a real module, we've run into a nasty
801 801 # problem: after script execution (via %run), the module where the user
802 802 # code ran is deleted. Now that this object is a true module (needed
803 803 # so docetst and other tools work correctly), the Python module
804 804 # teardown mechanism runs over it, and sets to None every variable
805 805 # present in that module. Top-level references to objects from the
806 806 # script survive, because the user_ns is updated with them. However,
807 807 # calling functions defined in the script that use other things from
808 808 # the script will fail, because the function's closure had references
809 809 # to the original objects, which are now all None. So we must protect
810 810 # these modules from deletion by keeping a cache.
811 811 #
812 812 # To avoid keeping stale modules around (we only need the one from the
813 813 # last run), we use a dict keyed with the full path to the script, so
814 814 # only the last version of the module is held in the cache. Note,
815 815 # however, that we must cache the module *namespace contents* (their
816 816 # __dict__). Because if we try to cache the actual modules, old ones
817 817 # (uncached) could be destroyed while still holding references (such as
818 818 # those held by GUI objects that tend to be long-lived)>
819 819 #
820 820 # The %reset command will flush this cache. See the cache_main_mod()
821 821 # and clear_main_mod_cache() methods for details on use.
822 822
823 823 # This is the cache used for 'main' namespaces
824 824 self._main_ns_cache = {}
825 825 # And this is the single instance of FakeModule whose __dict__ we keep
826 826 # copying and clearing for reuse on each %run
827 827 self._user_main_module = FakeModule()
828 828
829 829 # A table holding all the namespaces IPython deals with, so that
830 830 # introspection facilities can search easily.
831 831 self.ns_table = {'user':user_ns,
832 832 'user_global':user_global_ns,
833 833 'internal':self.internal_ns,
834 834 'builtin':__builtin__.__dict__
835 835 }
836 836
837 837 # Similarly, track all namespaces where references can be held and that
838 838 # we can safely clear (so it can NOT include builtin). This one can be
839 839 # a simple list. Note that the main execution namespaces, user_ns and
840 840 # user_global_ns, can NOT be listed here, as clearing them blindly
841 841 # causes errors in object __del__ methods. Instead, the reset() method
842 842 # clears them manually and carefully.
843 843 self.ns_refs_table = [ self.user_ns_hidden,
844 844 self.internal_ns, self._main_ns_cache ]
845 845
846 846 def make_user_namespaces(self, user_ns=None, user_global_ns=None):
847 847 """Return a valid local and global user interactive namespaces.
848 848
849 849 This builds a dict with the minimal information needed to operate as a
850 850 valid IPython user namespace, which you can pass to the various
851 851 embedding classes in ipython. The default implementation returns the
852 852 same dict for both the locals and the globals to allow functions to
853 853 refer to variables in the namespace. Customized implementations can
854 854 return different dicts. The locals dictionary can actually be anything
855 855 following the basic mapping protocol of a dict, but the globals dict
856 856 must be a true dict, not even a subclass. It is recommended that any
857 857 custom object for the locals namespace synchronize with the globals
858 858 dict somehow.
859 859
860 860 Raises TypeError if the provided globals namespace is not a true dict.
861 861
862 862 Parameters
863 863 ----------
864 864 user_ns : dict-like, optional
865 865 The current user namespace. The items in this namespace should
866 866 be included in the output. If None, an appropriate blank
867 867 namespace should be created.
868 868 user_global_ns : dict, optional
869 869 The current user global namespace. The items in this namespace
870 870 should be included in the output. If None, an appropriate
871 871 blank namespace should be created.
872 872
873 873 Returns
874 874 -------
875 875 A pair of dictionary-like object to be used as the local namespace
876 876 of the interpreter and a dict to be used as the global namespace.
877 877 """
878 878
879 879
880 880 # We must ensure that __builtin__ (without the final 's') is always
881 881 # available and pointing to the __builtin__ *module*. For more details:
882 882 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
883 883
884 884 if user_ns is None:
885 885 # Set __name__ to __main__ to better match the behavior of the
886 886 # normal interpreter.
887 887 user_ns = {'__name__' :'__main__',
888 888 '__builtin__' : __builtin__,
889 889 '__builtins__' : __builtin__,
890 890 }
891 891 else:
892 892 user_ns.setdefault('__name__','__main__')
893 893 user_ns.setdefault('__builtin__',__builtin__)
894 894 user_ns.setdefault('__builtins__',__builtin__)
895 895
896 896 if user_global_ns is None:
897 897 user_global_ns = user_ns
898 898 if type(user_global_ns) is not dict:
899 899 raise TypeError("user_global_ns must be a true dict; got %r"
900 900 % type(user_global_ns))
901 901
902 902 return user_ns, user_global_ns
903 903
904 904 def init_sys_modules(self):
905 905 # We need to insert into sys.modules something that looks like a
906 906 # module but which accesses the IPython namespace, for shelve and
907 907 # pickle to work interactively. Normally they rely on getting
908 908 # everything out of __main__, but for embedding purposes each IPython
909 909 # instance has its own private namespace, so we can't go shoving
910 910 # everything into __main__.
911 911
912 912 # note, however, that we should only do this for non-embedded
913 913 # ipythons, which really mimic the __main__.__dict__ with their own
914 914 # namespace. Embedded instances, on the other hand, should not do
915 915 # this because they need to manage the user local/global namespaces
916 916 # only, but they live within a 'normal' __main__ (meaning, they
917 917 # shouldn't overtake the execution environment of the script they're
918 918 # embedded in).
919 919
920 920 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
921 921
922 922 try:
923 923 main_name = self.user_ns['__name__']
924 924 except KeyError:
925 925 raise KeyError('user_ns dictionary MUST have a "__name__" key')
926 926 else:
927 927 sys.modules[main_name] = FakeModule(self.user_ns)
928 928
929 929 def init_user_ns(self):
930 930 """Initialize all user-visible namespaces to their minimum defaults.
931 931
932 932 Certain history lists are also initialized here, as they effectively
933 933 act as user namespaces.
934 934
935 935 Notes
936 936 -----
937 937 All data structures here are only filled in, they are NOT reset by this
938 938 method. If they were not empty before, data will simply be added to
939 939 therm.
940 940 """
941 941 # This function works in two parts: first we put a few things in
942 942 # user_ns, and we sync that contents into user_ns_hidden so that these
943 943 # initial variables aren't shown by %who. After the sync, we add the
944 944 # rest of what we *do* want the user to see with %who even on a new
945 945 # session (probably nothing, so theye really only see their own stuff)
946 946
947 947 # The user dict must *always* have a __builtin__ reference to the
948 948 # Python standard __builtin__ namespace, which must be imported.
949 949 # This is so that certain operations in prompt evaluation can be
950 950 # reliably executed with builtins. Note that we can NOT use
951 951 # __builtins__ (note the 's'), because that can either be a dict or a
952 952 # module, and can even mutate at runtime, depending on the context
953 953 # (Python makes no guarantees on it). In contrast, __builtin__ is
954 954 # always a module object, though it must be explicitly imported.
955 955
956 956 # For more details:
957 957 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
958 958 ns = dict(__builtin__ = __builtin__)
959 959
960 960 # Put 'help' in the user namespace
961 961 try:
962 962 from site import _Helper
963 963 ns['help'] = _Helper()
964 964 except ImportError:
965 965 warn('help() not available - check site.py')
966 966
967 967 # make global variables for user access to the histories
968 968 ns['_ih'] = self.history_manager.input_hist_parsed
969 969 ns['_oh'] = self.history_manager.output_hist
970 970 ns['_dh'] = self.history_manager.dir_hist
971 971
972 972 ns['_sh'] = shadowns
973 973
974 974 # user aliases to input and output histories. These shouldn't show up
975 975 # in %who, as they can have very large reprs.
976 976 ns['In'] = self.history_manager.input_hist_parsed
977 977 ns['Out'] = self.history_manager.output_hist
978 978
979 979 # Store myself as the public api!!!
980 980 ns['get_ipython'] = self.get_ipython
981 981
982 982 # Sync what we've added so far to user_ns_hidden so these aren't seen
983 983 # by %who
984 984 self.user_ns_hidden.update(ns)
985 985
986 986 # Anything put into ns now would show up in %who. Think twice before
987 987 # putting anything here, as we really want %who to show the user their
988 988 # stuff, not our variables.
989 989
990 990 # Finally, update the real user's namespace
991 991 self.user_ns.update(ns)
992 992
993 993 def reset(self):
994 994 """Clear all internal namespaces.
995 995
996 996 Note that this is much more aggressive than %reset, since it clears
997 997 fully all namespaces, as well as all input/output lists.
998 998 """
999 999 # Clear histories
1000 1000 self.history_manager.reset()
1001 1001
1002 1002 # Reset counter used to index all histories
1003 1003 self.execution_count = 0
1004 1004
1005 1005 # Restore the user namespaces to minimal usability
1006 1006 for ns in self.ns_refs_table:
1007 1007 ns.clear()
1008 1008
1009 1009 # The main execution namespaces must be cleared very carefully,
1010 1010 # skipping the deletion of the builtin-related keys, because doing so
1011 1011 # would cause errors in many object's __del__ methods.
1012 1012 for ns in [self.user_ns, self.user_global_ns]:
1013 1013 drop_keys = set(ns.keys())
1014 1014 drop_keys.discard('__builtin__')
1015 1015 drop_keys.discard('__builtins__')
1016 1016 for k in drop_keys:
1017 1017 del ns[k]
1018 1018
1019 1019 # Restore the user namespaces to minimal usability
1020 1020 self.init_user_ns()
1021 1021
1022 1022 # Restore the default and user aliases
1023 1023 self.alias_manager.clear_aliases()
1024 1024 self.alias_manager.init_aliases()
1025 1025
1026 1026 def reset_selective(self, regex=None):
1027 1027 """Clear selective variables from internal namespaces based on a
1028 1028 specified regular expression.
1029 1029
1030 1030 Parameters
1031 1031 ----------
1032 1032 regex : string or compiled pattern, optional
1033 1033 A regular expression pattern that will be used in searching
1034 1034 variable names in the users namespaces.
1035 1035 """
1036 1036 if regex is not None:
1037 1037 try:
1038 1038 m = re.compile(regex)
1039 1039 except TypeError:
1040 1040 raise TypeError('regex must be a string or compiled pattern')
1041 1041 # Search for keys in each namespace that match the given regex
1042 1042 # If a match is found, delete the key/value pair.
1043 1043 for ns in self.ns_refs_table:
1044 1044 for var in ns:
1045 1045 if m.search(var):
1046 1046 del ns[var]
1047 1047
1048 1048 def push(self, variables, interactive=True):
1049 1049 """Inject a group of variables into the IPython user namespace.
1050 1050
1051 1051 Parameters
1052 1052 ----------
1053 1053 variables : dict, str or list/tuple of str
1054 1054 The variables to inject into the user's namespace. If a dict, a
1055 1055 simple update is done. If a str, the string is assumed to have
1056 1056 variable names separated by spaces. A list/tuple of str can also
1057 1057 be used to give the variable names. If just the variable names are
1058 1058 give (list/tuple/str) then the variable values looked up in the
1059 1059 callers frame.
1060 1060 interactive : bool
1061 1061 If True (default), the variables will be listed with the ``who``
1062 1062 magic.
1063 1063 """
1064 1064 vdict = None
1065 1065
1066 1066 # We need a dict of name/value pairs to do namespace updates.
1067 1067 if isinstance(variables, dict):
1068 1068 vdict = variables
1069 1069 elif isinstance(variables, (basestring, list, tuple)):
1070 1070 if isinstance(variables, basestring):
1071 1071 vlist = variables.split()
1072 1072 else:
1073 1073 vlist = variables
1074 1074 vdict = {}
1075 1075 cf = sys._getframe(1)
1076 1076 for name in vlist:
1077 1077 try:
1078 1078 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1079 1079 except:
1080 1080 print ('Could not get variable %s from %s' %
1081 1081 (name,cf.f_code.co_name))
1082 1082 else:
1083 1083 raise ValueError('variables must be a dict/str/list/tuple')
1084 1084
1085 1085 # Propagate variables to user namespace
1086 1086 self.user_ns.update(vdict)
1087 1087
1088 1088 # And configure interactive visibility
1089 1089 config_ns = self.user_ns_hidden
1090 1090 if interactive:
1091 1091 for name, val in vdict.iteritems():
1092 1092 config_ns.pop(name, None)
1093 1093 else:
1094 1094 for name,val in vdict.iteritems():
1095 1095 config_ns[name] = val
1096 1096
1097 1097 #-------------------------------------------------------------------------
1098 1098 # Things related to object introspection
1099 1099 #-------------------------------------------------------------------------
1100 1100
1101 1101 def _ofind(self, oname, namespaces=None):
1102 1102 """Find an object in the available namespaces.
1103 1103
1104 1104 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1105 1105
1106 1106 Has special code to detect magic functions.
1107 1107 """
1108 1108 #oname = oname.strip()
1109 1109 #print '1- oname: <%r>' % oname # dbg
1110 1110 try:
1111 1111 oname = oname.strip().encode('ascii')
1112 1112 #print '2- oname: <%r>' % oname # dbg
1113 1113 except UnicodeEncodeError:
1114 1114 print 'Python identifiers can only contain ascii characters.'
1115 1115 return dict(found=False)
1116 1116
1117 1117 alias_ns = None
1118 1118 if namespaces is None:
1119 1119 # Namespaces to search in:
1120 1120 # Put them in a list. The order is important so that we
1121 1121 # find things in the same order that Python finds them.
1122 1122 namespaces = [ ('Interactive', self.user_ns),
1123 1123 ('IPython internal', self.internal_ns),
1124 1124 ('Python builtin', __builtin__.__dict__),
1125 1125 ('Alias', self.alias_manager.alias_table),
1126 1126 ]
1127 1127 alias_ns = self.alias_manager.alias_table
1128 1128
1129 1129 # initialize results to 'null'
1130 1130 found = False; obj = None; ospace = None; ds = None;
1131 1131 ismagic = False; isalias = False; parent = None
1132 1132
1133 1133 # We need to special-case 'print', which as of python2.6 registers as a
1134 1134 # function but should only be treated as one if print_function was
1135 1135 # loaded with a future import. In this case, just bail.
1136 1136 if (oname == 'print' and not (self.compile.compiler_flags &
1137 1137 __future__.CO_FUTURE_PRINT_FUNCTION)):
1138 1138 return {'found':found, 'obj':obj, 'namespace':ospace,
1139 1139 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1140 1140
1141 1141 # Look for the given name by splitting it in parts. If the head is
1142 1142 # found, then we look for all the remaining parts as members, and only
1143 1143 # declare success if we can find them all.
1144 1144 oname_parts = oname.split('.')
1145 1145 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1146 1146 for nsname,ns in namespaces:
1147 1147 try:
1148 1148 obj = ns[oname_head]
1149 1149 except KeyError:
1150 1150 continue
1151 1151 else:
1152 1152 #print 'oname_rest:', oname_rest # dbg
1153 1153 for part in oname_rest:
1154 1154 try:
1155 1155 parent = obj
1156 1156 obj = getattr(obj,part)
1157 1157 except:
1158 1158 # Blanket except b/c some badly implemented objects
1159 1159 # allow __getattr__ to raise exceptions other than
1160 1160 # AttributeError, which then crashes IPython.
1161 1161 break
1162 1162 else:
1163 1163 # If we finish the for loop (no break), we got all members
1164 1164 found = True
1165 1165 ospace = nsname
1166 1166 if ns == alias_ns:
1167 1167 isalias = True
1168 1168 break # namespace loop
1169 1169
1170 1170 # Try to see if it's magic
1171 1171 if not found:
1172 1172 if oname.startswith(ESC_MAGIC):
1173 1173 oname = oname[1:]
1174 1174 obj = getattr(self,'magic_'+oname,None)
1175 1175 if obj is not None:
1176 1176 found = True
1177 1177 ospace = 'IPython internal'
1178 1178 ismagic = True
1179 1179
1180 1180 # Last try: special-case some literals like '', [], {}, etc:
1181 1181 if not found and oname_head in ["''",'""','[]','{}','()']:
1182 1182 obj = eval(oname_head)
1183 1183 found = True
1184 1184 ospace = 'Interactive'
1185 1185
1186 1186 return {'found':found, 'obj':obj, 'namespace':ospace,
1187 1187 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1188 1188
1189 1189 def _ofind_property(self, oname, info):
1190 1190 """Second part of object finding, to look for property details."""
1191 1191 if info.found:
1192 1192 # Get the docstring of the class property if it exists.
1193 1193 path = oname.split('.')
1194 1194 root = '.'.join(path[:-1])
1195 1195 if info.parent is not None:
1196 1196 try:
1197 1197 target = getattr(info.parent, '__class__')
1198 1198 # The object belongs to a class instance.
1199 1199 try:
1200 1200 target = getattr(target, path[-1])
1201 1201 # The class defines the object.
1202 1202 if isinstance(target, property):
1203 1203 oname = root + '.__class__.' + path[-1]
1204 1204 info = Struct(self._ofind(oname))
1205 1205 except AttributeError: pass
1206 1206 except AttributeError: pass
1207 1207
1208 1208 # We return either the new info or the unmodified input if the object
1209 1209 # hadn't been found
1210 1210 return info
1211 1211
1212 1212 def _object_find(self, oname, namespaces=None):
1213 1213 """Find an object and return a struct with info about it."""
1214 1214 inf = Struct(self._ofind(oname, namespaces))
1215 1215 return Struct(self._ofind_property(oname, inf))
1216 1216
1217 1217 def _inspect(self, meth, oname, namespaces=None, **kw):
1218 1218 """Generic interface to the inspector system.
1219 1219
1220 1220 This function is meant to be called by pdef, pdoc & friends."""
1221 1221 info = self._object_find(oname)
1222 1222 if info.found:
1223 1223 pmethod = getattr(self.inspector, meth)
1224 1224 formatter = format_screen if info.ismagic else None
1225 1225 if meth == 'pdoc':
1226 1226 pmethod(info.obj, oname, formatter)
1227 1227 elif meth == 'pinfo':
1228 1228 pmethod(info.obj, oname, formatter, info, **kw)
1229 1229 else:
1230 1230 pmethod(info.obj, oname)
1231 1231 else:
1232 1232 print 'Object `%s` not found.' % oname
1233 1233 return 'not found' # so callers can take other action
1234 1234
1235 1235 def object_inspect(self, oname):
1236 1236 info = self._object_find(oname)
1237 1237 if info.found:
1238 1238 return self.inspector.info(info.obj, oname, info=info)
1239 1239 else:
1240 1240 return oinspect.object_info(name=oname, found=False)
1241 1241
1242 1242 #-------------------------------------------------------------------------
1243 1243 # Things related to history management
1244 1244 #-------------------------------------------------------------------------
1245 1245
1246 1246 def init_history(self):
1247 1247 """Sets up the command history, and starts regular autosaves."""
1248 1248 self.history_manager = HistoryManager(shell=self)
1249 1249
1250 1250 def history_saving_wrapper(self, func):
1251 1251 """ Wrap func for readline history saving
1252 1252
1253 1253 Convert func into callable that saves & restores
1254 1254 history around the call """
1255 1255
1256 1256 if self.has_readline:
1257 1257 from IPython.utils import rlineimpl as readline
1258 1258 else:
1259 1259 return func
1260 1260
1261 1261 def wrapper():
1262 1262 self.save_history()
1263 1263 try:
1264 1264 func()
1265 1265 finally:
1266 1266 self.reload_history()
1267 1267 return wrapper
1268 1268
1269 1269 def get_history(self, start=1, stop=None, raw=False, output=True):
1270 1270 return self.history_manager.get_history(start, stop, raw, output)
1271 1271
1272 1272
1273 1273 #-------------------------------------------------------------------------
1274 1274 # Things related to exception handling and tracebacks (not debugging)
1275 1275 #-------------------------------------------------------------------------
1276 1276
1277 1277 def init_traceback_handlers(self, custom_exceptions):
1278 1278 # Syntax error handler.
1279 1279 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1280 1280
1281 1281 # The interactive one is initialized with an offset, meaning we always
1282 1282 # want to remove the topmost item in the traceback, which is our own
1283 1283 # internal code. Valid modes: ['Plain','Context','Verbose']
1284 1284 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1285 1285 color_scheme='NoColor',
1286 1286 tb_offset = 1,
1287 1287 check_cache=self.compile.check_cache)
1288 1288
1289 1289 # The instance will store a pointer to the system-wide exception hook,
1290 1290 # so that runtime code (such as magics) can access it. This is because
1291 1291 # during the read-eval loop, it may get temporarily overwritten.
1292 1292 self.sys_excepthook = sys.excepthook
1293 1293
1294 1294 # and add any custom exception handlers the user may have specified
1295 1295 self.set_custom_exc(*custom_exceptions)
1296 1296
1297 1297 # Set the exception mode
1298 1298 self.InteractiveTB.set_mode(mode=self.xmode)
1299 1299
1300 1300 def set_custom_exc(self, exc_tuple, handler):
1301 1301 """set_custom_exc(exc_tuple,handler)
1302 1302
1303 1303 Set a custom exception handler, which will be called if any of the
1304 1304 exceptions in exc_tuple occur in the mainloop (specifically, in the
1305 1305 run_code() method.
1306 1306
1307 1307 Inputs:
1308 1308
1309 1309 - exc_tuple: a *tuple* of valid exceptions to call the defined
1310 1310 handler for. It is very important that you use a tuple, and NOT A
1311 1311 LIST here, because of the way Python's except statement works. If
1312 1312 you only want to trap a single exception, use a singleton tuple:
1313 1313
1314 1314 exc_tuple == (MyCustomException,)
1315 1315
1316 1316 - handler: this must be defined as a function with the following
1317 1317 basic interface::
1318 1318
1319 1319 def my_handler(self, etype, value, tb, tb_offset=None)
1320 1320 ...
1321 1321 # The return value must be
1322 1322 return structured_traceback
1323 1323
1324 1324 This will be made into an instance method (via types.MethodType)
1325 1325 of IPython itself, and it will be called if any of the exceptions
1326 1326 listed in the exc_tuple are caught. If the handler is None, an
1327 1327 internal basic one is used, which just prints basic info.
1328 1328
1329 1329 WARNING: by putting in your own exception handler into IPython's main
1330 1330 execution loop, you run a very good chance of nasty crashes. This
1331 1331 facility should only be used if you really know what you are doing."""
1332 1332
1333 1333 assert type(exc_tuple)==type(()) , \
1334 1334 "The custom exceptions must be given AS A TUPLE."
1335 1335
1336 1336 def dummy_handler(self,etype,value,tb):
1337 1337 print '*** Simple custom exception handler ***'
1338 1338 print 'Exception type :',etype
1339 1339 print 'Exception value:',value
1340 1340 print 'Traceback :',tb
1341 1341 print 'Source code :','\n'.join(self.buffer)
1342 1342
1343 1343 if handler is None: handler = dummy_handler
1344 1344
1345 1345 self.CustomTB = types.MethodType(handler,self)
1346 1346 self.custom_exceptions = exc_tuple
1347 1347
1348 1348 def excepthook(self, etype, value, tb):
1349 1349 """One more defense for GUI apps that call sys.excepthook.
1350 1350
1351 1351 GUI frameworks like wxPython trap exceptions and call
1352 1352 sys.excepthook themselves. I guess this is a feature that
1353 1353 enables them to keep running after exceptions that would
1354 1354 otherwise kill their mainloop. This is a bother for IPython
1355 1355 which excepts to catch all of the program exceptions with a try:
1356 1356 except: statement.
1357 1357
1358 1358 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1359 1359 any app directly invokes sys.excepthook, it will look to the user like
1360 1360 IPython crashed. In order to work around this, we can disable the
1361 1361 CrashHandler and replace it with this excepthook instead, which prints a
1362 1362 regular traceback using our InteractiveTB. In this fashion, apps which
1363 1363 call sys.excepthook will generate a regular-looking exception from
1364 1364 IPython, and the CrashHandler will only be triggered by real IPython
1365 1365 crashes.
1366 1366
1367 1367 This hook should be used sparingly, only in places which are not likely
1368 1368 to be true IPython errors.
1369 1369 """
1370 1370 self.showtraceback((etype,value,tb),tb_offset=0)
1371 1371
1372 1372 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1373 1373 exception_only=False):
1374 1374 """Display the exception that just occurred.
1375 1375
1376 1376 If nothing is known about the exception, this is the method which
1377 1377 should be used throughout the code for presenting user tracebacks,
1378 1378 rather than directly invoking the InteractiveTB object.
1379 1379
1380 1380 A specific showsyntaxerror() also exists, but this method can take
1381 1381 care of calling it if needed, so unless you are explicitly catching a
1382 1382 SyntaxError exception, don't try to analyze the stack manually and
1383 1383 simply call this method."""
1384 1384
1385 1385 try:
1386 1386 if exc_tuple is None:
1387 1387 etype, value, tb = sys.exc_info()
1388 1388 else:
1389 1389 etype, value, tb = exc_tuple
1390 1390
1391 1391 if etype is None:
1392 1392 if hasattr(sys, 'last_type'):
1393 1393 etype, value, tb = sys.last_type, sys.last_value, \
1394 1394 sys.last_traceback
1395 1395 else:
1396 1396 self.write_err('No traceback available to show.\n')
1397 1397 return
1398 1398
1399 1399 if etype is SyntaxError:
1400 1400 # Though this won't be called by syntax errors in the input
1401 1401 # line, there may be SyntaxError cases whith imported code.
1402 1402 self.showsyntaxerror(filename)
1403 1403 elif etype is UsageError:
1404 1404 print "UsageError:", value
1405 1405 else:
1406 1406 # WARNING: these variables are somewhat deprecated and not
1407 1407 # necessarily safe to use in a threaded environment, but tools
1408 1408 # like pdb depend on their existence, so let's set them. If we
1409 1409 # find problems in the field, we'll need to revisit their use.
1410 1410 sys.last_type = etype
1411 1411 sys.last_value = value
1412 1412 sys.last_traceback = tb
1413 1413
1414 1414 if etype in self.custom_exceptions:
1415 1415 # FIXME: Old custom traceback objects may just return a
1416 1416 # string, in that case we just put it into a list
1417 1417 stb = self.CustomTB(etype, value, tb, tb_offset)
1418 1418 if isinstance(ctb, basestring):
1419 1419 stb = [stb]
1420 1420 else:
1421 1421 if exception_only:
1422 1422 stb = ['An exception has occurred, use %tb to see '
1423 1423 'the full traceback.\n']
1424 1424 stb.extend(self.InteractiveTB.get_exception_only(etype,
1425 1425 value))
1426 1426 else:
1427 1427 stb = self.InteractiveTB.structured_traceback(etype,
1428 1428 value, tb, tb_offset=tb_offset)
1429 1429 # FIXME: the pdb calling should be done by us, not by
1430 1430 # the code computing the traceback.
1431 1431 if self.InteractiveTB.call_pdb:
1432 1432 # pdb mucks up readline, fix it back
1433 1433 self.set_readline_completer()
1434 1434
1435 1435 # Actually show the traceback
1436 1436 self._showtraceback(etype, value, stb)
1437 1437
1438 1438 except KeyboardInterrupt:
1439 1439 self.write_err("\nKeyboardInterrupt\n")
1440 1440
1441 1441 def _showtraceback(self, etype, evalue, stb):
1442 1442 """Actually show a traceback.
1443 1443
1444 1444 Subclasses may override this method to put the traceback on a different
1445 1445 place, like a side channel.
1446 1446 """
1447 1447 print >> io.Term.cout, self.InteractiveTB.stb2text(stb)
1448 1448
1449 1449 def showsyntaxerror(self, filename=None):
1450 1450 """Display the syntax error that just occurred.
1451 1451
1452 1452 This doesn't display a stack trace because there isn't one.
1453 1453
1454 1454 If a filename is given, it is stuffed in the exception instead
1455 1455 of what was there before (because Python's parser always uses
1456 1456 "<string>" when reading from a string).
1457 1457 """
1458 1458 etype, value, last_traceback = sys.exc_info()
1459 1459
1460 1460 # See note about these variables in showtraceback() above
1461 1461 sys.last_type = etype
1462 1462 sys.last_value = value
1463 1463 sys.last_traceback = last_traceback
1464 1464
1465 1465 if filename and etype is SyntaxError:
1466 1466 # Work hard to stuff the correct filename in the exception
1467 1467 try:
1468 1468 msg, (dummy_filename, lineno, offset, line) = value
1469 1469 except:
1470 1470 # Not the format we expect; leave it alone
1471 1471 pass
1472 1472 else:
1473 1473 # Stuff in the right filename
1474 1474 try:
1475 1475 # Assume SyntaxError is a class exception
1476 1476 value = SyntaxError(msg, (filename, lineno, offset, line))
1477 1477 except:
1478 1478 # If that failed, assume SyntaxError is a string
1479 1479 value = msg, (filename, lineno, offset, line)
1480 1480 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1481 1481 self._showtraceback(etype, value, stb)
1482 1482
1483 1483 #-------------------------------------------------------------------------
1484 1484 # Things related to readline
1485 1485 #-------------------------------------------------------------------------
1486 1486
1487 1487 def init_readline(self):
1488 1488 """Command history completion/saving/reloading."""
1489 1489
1490 1490 if self.readline_use:
1491 1491 import IPython.utils.rlineimpl as readline
1492 1492
1493 1493 self.rl_next_input = None
1494 1494 self.rl_do_indent = False
1495 1495
1496 1496 if not self.readline_use or not readline.have_readline:
1497 1497 self.has_readline = False
1498 1498 self.readline = None
1499 1499 # Set a number of methods that depend on readline to be no-op
1500 1500 self.set_readline_completer = no_op
1501 1501 self.set_custom_completer = no_op
1502 1502 self.set_completer_frame = no_op
1503 1503 warn('Readline services not available or not loaded.')
1504 1504 else:
1505 1505 self.has_readline = True
1506 1506 self.readline = readline
1507 1507 sys.modules['readline'] = readline
1508 1508
1509 1509 # Platform-specific configuration
1510 1510 if os.name == 'nt':
1511 1511 # FIXME - check with Frederick to see if we can harmonize
1512 1512 # naming conventions with pyreadline to avoid this
1513 1513 # platform-dependent check
1514 1514 self.readline_startup_hook = readline.set_pre_input_hook
1515 1515 else:
1516 1516 self.readline_startup_hook = readline.set_startup_hook
1517 1517
1518 1518 # Load user's initrc file (readline config)
1519 1519 # Or if libedit is used, load editrc.
1520 1520 inputrc_name = os.environ.get('INPUTRC')
1521 1521 if inputrc_name is None:
1522 1522 home_dir = get_home_dir()
1523 1523 if home_dir is not None:
1524 1524 inputrc_name = '.inputrc'
1525 1525 if readline.uses_libedit:
1526 1526 inputrc_name = '.editrc'
1527 1527 inputrc_name = os.path.join(home_dir, inputrc_name)
1528 1528 if os.path.isfile(inputrc_name):
1529 1529 try:
1530 1530 readline.read_init_file(inputrc_name)
1531 1531 except:
1532 1532 warn('Problems reading readline initialization file <%s>'
1533 1533 % inputrc_name)
1534 1534
1535 1535 # Configure readline according to user's prefs
1536 1536 # This is only done if GNU readline is being used. If libedit
1537 1537 # is being used (as on Leopard) the readline config is
1538 1538 # not run as the syntax for libedit is different.
1539 1539 if not readline.uses_libedit:
1540 1540 for rlcommand in self.readline_parse_and_bind:
1541 1541 #print "loading rl:",rlcommand # dbg
1542 1542 readline.parse_and_bind(rlcommand)
1543 1543
1544 1544 # Remove some chars from the delimiters list. If we encounter
1545 1545 # unicode chars, discard them.
1546 1546 delims = readline.get_completer_delims().encode("ascii", "ignore")
1547 1547 delims = delims.translate(None, self.readline_remove_delims)
1548 1548 delims = delims.replace(ESC_MAGIC, '')
1549 1549 readline.set_completer_delims(delims)
1550 1550 # otherwise we end up with a monster history after a while:
1551 1551 readline.set_history_length(self.history_length)
1552 1552
1553 1553 # Load the last 1000 lines from history
1554 1554 for cell in self.history_manager.tail_db_history(1000):
1555 1555 if cell.strip(): # Ignore blank lines
1556 1556 for line in cell.splitlines():
1557 1557 readline.add_history(line)
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
2107 2107 # All user code execution must happen with our context managers active
2108 2108 with nested(self.builtin_trap, self.display_trap):
2109 2109
2110 2110 # Single-block input should behave like an interactive prompt
2111 2111 if len(blocks) == 1:
2112 2112 # since we return here, we need to update the execution count
2113 2113 out = self.run_one_block(blocks[0])
2114 2114 self.execution_count += 1
2115 2115 return out
2116 2116
2117 2117 # In multi-block input, if the last block is a simple (one-two
2118 2118 # lines) expression, run it in single mode so it produces output.
2119 2119 # Otherwise just feed the whole thing to run_code. This seems like
2120 2120 # a reasonable usability design.
2121 2121 last = blocks[-1]
2122 2122 last_nlines = len(last.splitlines())
2123 2123
2124 2124 # Note: below, whenever we call run_code, we must sync history
2125 2125 # ourselves, because run_code is NOT meant to manage history at all.
2126 2126 if last_nlines < 2:
2127 2127 # Here we consider the cell split between 'body' and 'last',
2128 2128 # store all history and execute 'body', and if successful, then
2129 2129 # proceed to execute 'last'.
2130 2130
2131 2131 # Get the main body to run as a cell
2132 2132 ipy_body = ''.join(blocks[:-1])
2133 2133 retcode = self.run_source(ipy_body, symbol='exec',
2134 2134 post_execute=False)
2135 2135 if retcode==0:
2136 2136 # And the last expression via runlines so it produces output
2137 2137 self.run_one_block(last)
2138 2138 else:
2139 2139 # Run the whole cell as one entity, storing both raw and
2140 2140 # processed input in history
2141 2141 self.run_source(ipy_cell, symbol='exec')
2142 2142
2143 2143 # Each cell is a *single* input, regardless of how many lines it has
2144 2144 self.execution_count += 1
2145 2145
2146 2146 def run_one_block(self, block):
2147 2147 """Run a single interactive block of source code.
2148 2148
2149 2149 If the block is single-line, dynamic transformations are applied to it
2150 2150 (like automagics, autocall and alias recognition).
2151 2151
2152 2152 If the block is multi-line, it must consist of valid Python code only.
2153 2153
2154 2154 Parameters
2155 2155 ----------
2156 2156 block : string
2157 2157 A (possibly multiline) string of code to be executed.
2158 2158
2159 2159 Returns
2160 2160 -------
2161 2161 The output of the underlying execution method used, be it
2162 2162 :meth:`run_source` or :meth:`run_single_line`.
2163 2163 """
2164 2164 if len(block.splitlines()) <= 1:
2165 2165 out = self.run_single_line(block)
2166 2166 else:
2167 2167 # Call run_source, which correctly compiles the input cell.
2168 2168 # run_code must only be called when we know we have a code object,
2169 2169 # as it does a naked exec and the compilation mode may not be what
2170 2170 # we wanted.
2171 2171 out = self.run_source(block)
2172 2172 return out
2173 2173
2174 2174 def run_single_line(self, line):
2175 2175 """Run a single-line interactive statement.
2176 2176
2177 2177 This assumes the input has been transformed to IPython syntax by
2178 2178 applying all static transformations (those with an explicit prefix like
2179 2179 % or !), but it will further try to apply the dynamic ones.
2180 2180
2181 2181 It does not update history.
2182 2182 """
2183 2183 tline = self.prefilter_manager.prefilter_line(line)
2184 2184 return self.run_source(tline)
2185 2185
2186 2186 # PENDING REMOVAL: this method is slated for deletion, once our new
2187 2187 # input logic has been 100% moved to frontends and is stable.
2188 2188 def runlines(self, lines, clean=False):
2189 2189 """Run a string of one or more lines of source.
2190 2190
2191 2191 This method is capable of running a string containing multiple source
2192 2192 lines, as if they had been entered at the IPython prompt. Since it
2193 2193 exposes IPython's processing machinery, the given strings can contain
2194 2194 magic calls (%magic), special shell access (!cmd), etc.
2195 2195 """
2196 2196
2197 2197 if isinstance(lines, (list, tuple)):
2198 2198 lines = '\n'.join(lines)
2199 2199
2200 2200 if clean:
2201 2201 lines = self._cleanup_ipy_script(lines)
2202 2202
2203 2203 # We must start with a clean buffer, in case this is run from an
2204 2204 # interactive IPython session (via a magic, for example).
2205 2205 self.reset_buffer()
2206 2206 lines = lines.splitlines()
2207 2207
2208 2208 # Since we will prefilter all lines, store the user's raw input too
2209 2209 # before we apply any transformations
2210 2210 self.buffer_raw[:] = [ l+'\n' for l in lines]
2211 2211
2212 2212 more = False
2213 2213 prefilter_lines = self.prefilter_manager.prefilter_lines
2214 2214 with nested(self.builtin_trap, self.display_trap):
2215 2215 for line in lines:
2216 2216 # skip blank lines so we don't mess up the prompt counter, but
2217 2217 # do NOT skip even a blank line if we are in a code block (more
2218 2218 # is true)
2219 2219
2220 2220 if line or more:
2221 2221 more = self.push_line(prefilter_lines(line, more))
2222 2222 # IPython's run_source returns None if there was an error
2223 2223 # compiling the code. This allows us to stop processing
2224 2224 # right away, so the user gets the error message at the
2225 2225 # right place.
2226 2226 if more is None:
2227 2227 break
2228 2228 # final newline in case the input didn't have it, so that the code
2229 2229 # actually does get executed
2230 2230 if more:
2231 2231 self.push_line('\n')
2232 2232
2233 2233 def run_source(self, source, filename=None,
2234 2234 symbol='single', post_execute=True):
2235 2235 """Compile and run some source in the interpreter.
2236 2236
2237 2237 Arguments are as for compile_command().
2238 2238
2239 2239 One several things can happen:
2240 2240
2241 2241 1) The input is incorrect; compile_command() raised an
2242 2242 exception (SyntaxError or OverflowError). A syntax traceback
2243 2243 will be printed by calling the showsyntaxerror() method.
2244 2244
2245 2245 2) The input is incomplete, and more input is required;
2246 2246 compile_command() returned None. Nothing happens.
2247 2247
2248 2248 3) The input is complete; compile_command() returned a code
2249 2249 object. The code is executed by calling self.run_code() (which
2250 2250 also handles run-time exceptions, except for SystemExit).
2251 2251
2252 2252 The return value is:
2253 2253
2254 2254 - True in case 2
2255 2255
2256 2256 - False in the other cases, unless an exception is raised, where
2257 2257 None is returned instead. This can be used by external callers to
2258 2258 know whether to continue feeding input or not.
2259 2259
2260 2260 The return value can be used to decide whether to use sys.ps1 or
2261 2261 sys.ps2 to prompt the next line."""
2262 2262
2263 2263 # We need to ensure that the source is unicode from here on.
2264 2264 if type(source)==str:
2265 2265 usource = source.decode(self.stdin_encoding)
2266 2266 else:
2267 2267 usource = source
2268 2268
2269 2269 if 0: # dbg
2270 2270 print 'Source:', repr(source) # dbg
2271 2271 print 'USource:', repr(usource) # dbg
2272 2272 print 'type:', type(source) # dbg
2273 2273 print 'encoding', self.stdin_encoding # dbg
2274 2274
2275 2275 try:
2276 2276 code = self.compile(usource, symbol, self.execution_count)
2277 2277 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
2278 2278 # Case 1
2279 2279 self.showsyntaxerror(filename)
2280 2280 return None
2281 2281
2282 2282 if code is None:
2283 2283 # Case 2
2284 2284 return True
2285 2285
2286 2286 # Case 3
2287 2287 # We store the code object so that threaded shells and
2288 2288 # custom exception handlers can access all this info if needed.
2289 2289 # The source corresponding to this can be obtained from the
2290 2290 # buffer attribute as '\n'.join(self.buffer).
2291 2291 self.code_to_run = code
2292 2292 # now actually execute the code object
2293 2293 if self.run_code(code, post_execute) == 0:
2294 2294 return False
2295 2295 else:
2296 2296 return None
2297 2297
2298 2298 # For backwards compatibility
2299 2299 runsource = run_source
2300 2300
2301 2301 def run_code(self, code_obj, post_execute=True):
2302 2302 """Execute a code object.
2303 2303
2304 2304 When an exception occurs, self.showtraceback() is called to display a
2305 2305 traceback.
2306 2306
2307 2307 Return value: a flag indicating whether the code to be run completed
2308 2308 successfully:
2309 2309
2310 2310 - 0: successful execution.
2311 2311 - 1: an error occurred.
2312 2312 """
2313 2313
2314 2314 # Set our own excepthook in case the user code tries to call it
2315 2315 # directly, so that the IPython crash handler doesn't get triggered
2316 2316 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2317 2317
2318 2318 # we save the original sys.excepthook in the instance, in case config
2319 2319 # code (such as magics) needs access to it.
2320 2320 self.sys_excepthook = old_excepthook
2321 2321 outflag = 1 # happens in more places, so it's easier as default
2322 2322 try:
2323 2323 try:
2324 2324 self.hooks.pre_run_code_hook()
2325 2325 #rprint('Running code', repr(code_obj)) # dbg
2326 2326 exec code_obj in self.user_global_ns, self.user_ns
2327 2327 finally:
2328 2328 # Reset our crash handler in place
2329 2329 sys.excepthook = old_excepthook
2330 2330 except SystemExit:
2331 2331 self.reset_buffer()
2332 2332 self.showtraceback(exception_only=True)
2333 2333 warn("To exit: use any of 'exit', 'quit', %Exit or Ctrl-D.", level=1)
2334 2334 except self.custom_exceptions:
2335 2335 etype,value,tb = sys.exc_info()
2336 2336 self.CustomTB(etype,value,tb)
2337 2337 except:
2338 2338 self.showtraceback()
2339 2339 else:
2340 2340 outflag = 0
2341 2341 if softspace(sys.stdout, 0):
2342 2342 print
2343 2343
2344 2344 # Execute any registered post-execution functions. Here, any errors
2345 2345 # are reported only minimally and just on the terminal, because the
2346 2346 # main exception channel may be occupied with a user traceback.
2347 2347 # FIXME: we need to think this mechanism a little more carefully.
2348 2348 if post_execute:
2349 2349 for func in self._post_execute:
2350 2350 try:
2351 2351 func()
2352 2352 except:
2353 2353 head = '[ ERROR ] Evaluating post_execute function: %s' % \
2354 2354 func
2355 2355 print >> io.Term.cout, head
2356 2356 print >> io.Term.cout, self._simple_error()
2357 2357 print >> io.Term.cout, 'Removing from post_execute'
2358 2358 self._post_execute.remove(func)
2359 2359
2360 2360 # Flush out code object which has been run (and source)
2361 2361 self.code_to_run = None
2362 2362 return outflag
2363 2363
2364 2364 # For backwards compatibility
2365 2365 runcode = run_code
2366 2366
2367 2367 # PENDING REMOVAL: this method is slated for deletion, once our new
2368 2368 # input logic has been 100% moved to frontends and is stable.
2369 2369 def push_line(self, line):
2370 2370 """Push a line to the interpreter.
2371 2371
2372 2372 The line should not have a trailing newline; it may have
2373 2373 internal newlines. The line is appended to a buffer and the
2374 2374 interpreter's run_source() method is called with the
2375 2375 concatenated contents of the buffer as source. If this
2376 2376 indicates that the command was executed or invalid, the buffer
2377 2377 is reset; otherwise, the command is incomplete, and the buffer
2378 2378 is left as it was after the line was appended. The return
2379 2379 value is 1 if more input is required, 0 if the line was dealt
2380 2380 with in some way (this is the same as run_source()).
2381 2381 """
2382 2382
2383 2383 # autoindent management should be done here, and not in the
2384 2384 # interactive loop, since that one is only seen by keyboard input. We
2385 2385 # need this done correctly even for code run via runlines (which uses
2386 2386 # push).
2387 2387
2388 2388 #print 'push line: <%s>' % line # dbg
2389 2389 self.buffer.append(line)
2390 2390 full_source = '\n'.join(self.buffer)
2391 2391 more = self.run_source(full_source, self.filename)
2392 2392 if not more:
2393 2393 self.history_manager.store_inputs('\n'.join(self.buffer_raw),
2394 2394 full_source)
2395 2395 self.reset_buffer()
2396 2396 self.execution_count += 1
2397 2397 return more
2398 2398
2399 2399 def reset_buffer(self):
2400 2400 """Reset the input buffer."""
2401 2401 self.buffer[:] = []
2402 2402 self.buffer_raw[:] = []
2403 2403 self.input_splitter.reset()
2404 2404
2405 2405 # For backwards compatibility
2406 2406 resetbuffer = reset_buffer
2407 2407
2408 2408 def _is_secondary_block_start(self, s):
2409 2409 if not s.endswith(':'):
2410 2410 return False
2411 2411 if (s.startswith('elif') or
2412 2412 s.startswith('else') or
2413 2413 s.startswith('except') or
2414 2414 s.startswith('finally')):
2415 2415 return True
2416 2416
2417 2417 def _cleanup_ipy_script(self, script):
2418 2418 """Make a script safe for self.runlines()
2419 2419
2420 2420 Currently, IPython is lines based, with blocks being detected by
2421 2421 empty lines. This is a problem for block based scripts that may
2422 2422 not have empty lines after blocks. This script adds those empty
2423 2423 lines to make scripts safe for running in the current line based
2424 2424 IPython.
2425 2425 """
2426 2426 res = []
2427 2427 lines = script.splitlines()
2428 2428 level = 0
2429 2429
2430 2430 for l in lines:
2431 2431 lstripped = l.lstrip()
2432 2432 stripped = l.strip()
2433 2433 if not stripped:
2434 2434 continue
2435 2435 newlevel = len(l) - len(lstripped)
2436 2436 if level > 0 and newlevel == 0 and \
2437 2437 not self._is_secondary_block_start(stripped):
2438 2438 # add empty line
2439 2439 res.append('')
2440 2440 res.append(l)
2441 2441 level = newlevel
2442 2442
2443 2443 return '\n'.join(res) + '\n'
2444 2444
2445 2445 #-------------------------------------------------------------------------
2446 2446 # Things related to GUI support and pylab
2447 2447 #-------------------------------------------------------------------------
2448 2448
2449 2449 def enable_pylab(self, gui=None):
2450 2450 raise NotImplementedError('Implement enable_pylab in a subclass')
2451 2451
2452 2452 #-------------------------------------------------------------------------
2453 2453 # Utilities
2454 2454 #-------------------------------------------------------------------------
2455 2455
2456 2456 def var_expand(self,cmd,depth=0):
2457 2457 """Expand python variables in a string.
2458 2458
2459 2459 The depth argument indicates how many frames above the caller should
2460 2460 be walked to look for the local namespace where to expand variables.
2461 2461
2462 2462 The global namespace for expansion is always the user's interactive
2463 2463 namespace.
2464 2464 """
2465 2465
2466 2466 return str(ItplNS(cmd,
2467 2467 self.user_ns, # globals
2468 2468 # Skip our own frame in searching for locals:
2469 2469 sys._getframe(depth+1).f_locals # locals
2470 2470 ))
2471 2471
2472 2472 def mktempfile(self, data=None, prefix='ipython_edit_'):
2473 2473 """Make a new tempfile and return its filename.
2474 2474
2475 2475 This makes a call to tempfile.mktemp, but it registers the created
2476 2476 filename internally so ipython cleans it up at exit time.
2477 2477
2478 2478 Optional inputs:
2479 2479
2480 2480 - data(None): if data is given, it gets written out to the temp file
2481 2481 immediately, and the file is closed again."""
2482 2482
2483 2483 filename = tempfile.mktemp('.py', prefix)
2484 2484 self.tempfiles.append(filename)
2485 2485
2486 2486 if data:
2487 2487 tmp_file = open(filename,'w')
2488 2488 tmp_file.write(data)
2489 2489 tmp_file.close()
2490 2490 return filename
2491 2491
2492 2492 # TODO: This should be removed when Term is refactored.
2493 2493 def write(self,data):
2494 2494 """Write a string to the default output"""
2495 2495 io.Term.cout.write(data)
2496 2496
2497 2497 # TODO: This should be removed when Term is refactored.
2498 2498 def write_err(self,data):
2499 2499 """Write a string to the default error output"""
2500 2500 io.Term.cerr.write(data)
2501 2501
2502 2502 def ask_yes_no(self,prompt,default=True):
2503 2503 if self.quiet:
2504 2504 return True
2505 2505 return ask_yes_no(prompt,default)
2506 2506
2507 2507 def show_usage(self):
2508 2508 """Show a usage message"""
2509 2509 page.page(IPython.core.usage.interactive_usage)
2510 2510
2511 2511 #-------------------------------------------------------------------------
2512 2512 # Things related to IPython exiting
2513 2513 #-------------------------------------------------------------------------
2514 2514 def atexit_operations(self):
2515 2515 """This will be executed at the time of exit.
2516 2516
2517 2517 Cleanup operations and saving of persistent data that is done
2518 2518 unconditionally by IPython should be performed here.
2519 2519
2520 2520 For things that may depend on startup flags or platform specifics (such
2521 2521 as having readline or not), register a separate atexit function in the
2522 2522 code that has the appropriate information, rather than trying to
2523 2523 clutter
2524 2524 """
2525 2525 # Cleanup all tempfiles left around
2526 2526 for tfile in self.tempfiles:
2527 2527 try:
2528 2528 os.unlink(tfile)
2529 2529 except OSError:
2530 2530 pass
2531
2532 # Write anything in the history cache to the database.
2533 self.history_manager.writeout_cache()
2531 2534
2532 2535 # Clear all user namespaces to release all references cleanly.
2533 2536 self.reset()
2534 2537
2535 2538 # Run user hooks
2536 2539 self.hooks.shutdown_hook()
2537 2540
2538 2541 def cleanup(self):
2539 2542 self.restore_sys_module_state()
2540 2543
2541 2544
2542 2545 class InteractiveShellABC(object):
2543 2546 """An abstract base class for InteractiveShell."""
2544 2547 __metaclass__ = abc.ABCMeta
2545 2548
2546 2549 InteractiveShellABC.register(InteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now