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