##// END OF EJS Templates
Passing IPython.core tests.
Thomas Kluyver -
Show More
@@ -1,575 +1,581 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 re
17 import re
18 import sqlite3
18 import sqlite3
19
19
20 # Our own packages
20 # Our own packages
21 from IPython.config.configurable import Configurable
21 from IPython.config.configurable import Configurable
22 import IPython.utils.io
22 import IPython.utils.io
23
23
24 from IPython.testing import decorators as testdec
24 from IPython.testing import decorators as testdec
25 from IPython.utils.io import ask_yes_no
25 from IPython.utils.io import ask_yes_no
26 from IPython.utils.traitlets import Bool, Dict, Instance, Int, List, Unicode
26 from IPython.utils.traitlets import Bool, Dict, Instance, Int, List, Unicode
27 from IPython.utils.warn import warn
27 from IPython.utils.warn import warn
28
28
29 #-----------------------------------------------------------------------------
29 #-----------------------------------------------------------------------------
30 # Classes and functions
30 # Classes and functions
31 #-----------------------------------------------------------------------------
31 #-----------------------------------------------------------------------------
32
32
33 class HistoryManager(Configurable):
33 class HistoryManager(Configurable):
34 """A class to organize all history-related functionality in one place.
34 """A class to organize all history-related functionality in one place.
35 """
35 """
36 # Public interface
36 # Public interface
37
37
38 # An instance of the IPython shell we are attached to
38 # An instance of the IPython shell we are attached to
39 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
39 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
40 # Lists to hold processed and raw history. These start with a blank entry
40 # Lists to hold processed and raw history. These start with a blank entry
41 # so that we can index them starting from 1
41 # so that we can index them starting from 1
42 input_hist_parsed = List([""])
42 input_hist_parsed = List([""])
43 input_hist_raw = List([""])
43 input_hist_raw = List([""])
44 # A list of directories visited during session
44 # A list of directories visited during session
45 dir_hist = List()
45 dir_hist = List()
46 # A dict of output history, keyed with ints from the shell's execution count
46 # A dict of output history, keyed with ints from the shell's execution count
47 output_hist = Dict()
47 output_hist = Dict()
48 # String holding the path to the history file
48 # String holding the path to the history file
49 hist_file = Unicode()
49 hist_file = Unicode()
50 # The SQLite database
50 # The SQLite database
51 db = Instance(sqlite3.Connection)
51 db = Instance(sqlite3.Connection)
52 # The number of the current session in the history database
52 # The number of the current session in the history database
53 session_number = Int()
53 session_number = Int()
54 # Should we log output to the database? (default no)
54 # Should we log output to the database? (default no)
55 db_log_output = Bool(False, config=True)
55 db_log_output = Bool(False, config=True)
56 # Write to database every x commands (higher values save disk access & power)
56 # Write to database every x commands (higher values save disk access & power)
57 # Values of 1 or less effectively disable caching.
57 # Values of 1 or less effectively disable caching.
58 db_cache_size = Int(0, config=True)
58 db_cache_size = Int(0, config=True)
59 # The input and output caches
59 # The input and output caches
60 db_input_cache = List()
60 db_input_cache = List()
61 db_output_cache = List()
61 db_output_cache = List()
62
62
63 # Private interface
63 # Private interface
64 # Variables used to store the three last inputs from the user. On each new
64 # Variables used to store the three last inputs from the user. On each new
65 # history update, we populate the user's namespace with these, shifted as
65 # history update, we populate the user's namespace with these, shifted as
66 # necessary.
66 # necessary.
67 _i00, _i, _ii, _iii = '','','',''
67 _i00, _i, _ii, _iii = '','','',''
68
68
69 # A set with all forms of the exit command, so that we don't store them in
69 # A set with all forms of the exit command, so that we don't store them in
70 # the history (it's annoying to rewind the first entry and land on an exit
70 # the history (it's annoying to rewind the first entry and land on an exit
71 # call).
71 # call).
72 _exit_commands = None
72 _exit_commands = None
73
73
74 def __init__(self, shell, config=None):
74 def __init__(self, shell, config=None):
75 """Create a new history manager associated with a shell instance.
75 """Create a new history manager associated with a shell instance.
76 """
76 """
77 # We need a pointer back to the shell for various tasks.
77 # We need a pointer back to the shell for various tasks.
78 super(HistoryManager, self).__init__(shell=shell, config=config)
78 super(HistoryManager, self).__init__(shell=shell, config=config)
79
79
80 # list of visited directories
80 # list of visited directories
81 try:
81 try:
82 self.dir_hist = [os.getcwd()]
82 self.dir_hist = [os.getcwd()]
83 except OSError:
83 except OSError:
84 self.dir_hist = []
84 self.dir_hist = []
85
85
86 # Now the history file
86 # Now the history file
87 if shell.profile:
87 if shell.profile:
88 histfname = 'history-%s' % shell.profile
88 histfname = 'history-%s' % shell.profile
89 else:
89 else:
90 histfname = 'history'
90 histfname = 'history'
91 self.hist_file = os.path.join(shell.ipython_dir, histfname + '.sqlite')
91 self.hist_file = os.path.join(shell.ipython_dir, histfname + '.sqlite')
92 self.init_db()
92 self.init_db()
93
93
94 self._i00, self._i, self._ii, self._iii = '','','',''
94 self._i00, self._i, self._ii, self._iii = '','','',''
95
95
96 self._exit_commands = set(['Quit', 'quit', 'Exit', 'exit', '%Quit',
96 self._exit_commands = set(['Quit', 'quit', 'Exit', 'exit', '%Quit',
97 '%quit', '%Exit', '%exit'])
97 '%quit', '%Exit', '%exit'])
98
98
99 def init_db(self):
99 def init_db(self):
100 """Connect to the database and get new session number."""
100 self.db = sqlite3.connect(self.hist_file)
101 self.db = sqlite3.connect(self.hist_file)
101 self.db.execute("""CREATE TABLE IF NOT EXISTS history
102 self.db.execute("""CREATE TABLE IF NOT EXISTS history
102 (session integer, line integer, source text, source_raw text,
103 (session integer, line integer, source text, source_raw text,
103 PRIMARY KEY (session, line))""")
104 PRIMARY KEY (session, line))""")
104 # Output history is optional, but ensure the table's there so it can be
105 # Output history is optional, but ensure the table's there so it can be
105 # enabled later.
106 # enabled later.
106 self.db.execute("""CREATE TABLE IF NOT EXISTS output_history
107 self.db.execute("""CREATE TABLE IF NOT EXISTS output_history
107 (session integer, line integer, output text,
108 (session integer, line integer, output text,
108 PRIMARY KEY (session, line))""")
109 PRIMARY KEY (session, line))""")
109 cur = self.db.execute("""SELECT name FROM sqlite_master WHERE
110 cur = self.db.execute("""SELECT name FROM sqlite_master WHERE
110 type='table' AND name='singletons'""")
111 type='table' AND name='singletons'""")
111 if not cur.fetchone():
112 if not cur.fetchone():
112 self.db.execute("""CREATE TABLE singletons
113 self.db.execute("""CREATE TABLE singletons
113 (name text PRIMARY KEY, value)""")
114 (name text PRIMARY KEY, value)""")
114 self.db.execute("""INSERT INTO singletons VALUES
115 self.db.execute("""INSERT INTO singletons VALUES
115 ('session_number', 1)""")
116 ('session_number', 1)""")
116 self.db.commit()
117 self.db.commit()
117 cur = self.db.execute("""SELECT value FROM singletons WHERE
118 cur = self.db.execute("""SELECT value FROM singletons WHERE
118 name='session_number'""")
119 name='session_number'""")
119 self.session_number = cur.fetchone()[0]
120 self.session_number = cur.fetchone()[0]
120
121
121 #Increment by one for next session.
122 #Increment by one for next session.
122 self.db.execute("""UPDATE singletons SET value=? WHERE
123 self.db.execute("""UPDATE singletons SET value=? WHERE
123 name='session_number'""", (self.session_number+1,))
124 name='session_number'""", (self.session_number+1,))
124 self.db.commit()
125 self.db.commit()
125
126
126 def get_hist_tail(self, n=10, raw=True):
127 def get_hist_tail(self, n=10, raw=True):
127 """Get the last n lines from the history database."""
128 """Get the last n lines from the history database."""
128 toget = 'source_raw' if raw else 'source'
129 toget = 'source_raw' if raw else 'source'
129 cur = self.db.execute("SELECT session, line, " + toget +\
130 cur = self.db.execute("SELECT session, line, " + toget +\
130 " FROM history ORDER BY session DESC, line DESC LIMIT ?""", (n,))
131 " FROM history ORDER BY session DESC, line DESC LIMIT ?""", (n,))
131 return reversed(cur.fetchall())
132 return reversed(cur.fetchall())
132
133
133 def get_hist_search(self, pattern="*", raw=True):
134 def get_hist_search(self, pattern="*", raw=True):
134 """Search the database using unix glob-style matching (wildcards * and
135 """Search the database using unix glob-style matching (wildcards * and
135 ?, escape using \).
136 ?, escape using \).
136
137
137 Returns
138 Returns
138 -------
139 -------
139 An iterator over tuples: (session, line_number, command)
140 An iterator over tuples: (session, line_number, command)
140 """
141 """
141 toget = "source_raw" if raw else source
142 toget = "source_raw" if raw else source
142 return self.db.execute("SELECT session, line, " +toget+ \
143 return self.db.execute("SELECT session, line, " +toget+ \
143 "FROM history WHERE" +toget+ "GLOB ?", (pattern,))
144 "FROM history WHERE" +toget+ "GLOB ?", (pattern,))
144
145
145 def _get_hist_session(self, start=1, stop=None, raw=True, output=False):
146 def _get_hist_session(self, start=1, stop=None, raw=True, output=False):
146 """Get input and output history from the current session. Called by
147 """Get input and output history from the current session. Called by
147 get_history, and takes similar parameters."""
148 get_history, and takes similar parameters."""
148 input_hist = self.input_hist_raw if raw else self.input_hist_parsed
149 input_hist = self.input_hist_raw if raw else self.input_hist_parsed
149
150
150 n = len(input_hist)
151 n = len(input_hist)
151 if start < 0:
152 if start < 0:
152 start += n
153 start += n
153 if not stop:
154 if not stop:
154 stop = n
155 stop = n
155 elif stop < 0:
156 elif stop < 0:
156 stop += n
157 stop += n
157
158
158 for i in range(start, stop):
159 for i in range(start, stop):
159 if output:
160 if output:
160 line = (input_hist[i], self.output_hist.get(i))
161 line = (input_hist[i], self.output_hist.get(i))
161 else:
162 else:
162 line = input_hist[i]
163 line = input_hist[i]
163 yield (0, i, line)
164 yield (0, i, line)
164
165
165 def get_history(self, session=0, start=1, stop=None, raw=True,output=False):
166 def get_history(self, session=0, start=1, stop=None, raw=True,output=False):
166 """Retrieve input by session.
167 """Retrieve input by session.
167
168
168 Parameters
169 Parameters
169 ----------
170 ----------
170 session : int
171 session : int
171 Session number to retrieve. The current session is 0, and negative
172 Session number to retrieve. The current session is 0, and negative
172 numbers count back from current session, so -1 is previous session.
173 numbers count back from current session, so -1 is previous session.
173 start : int
174 start : int
174 First line to retrieve.
175 First line to retrieve.
175 stop : int
176 stop : int
176 Last line to retrieve. If None, retrieve to the end of the session.
177 End of line range (excluded from output itself). If None, retrieve
178 to the end of the session.
177 raw : bool
179 raw : bool
178 If True, return untranslated input
180 If True, return untranslated input
179 output : bool
181 output : bool
180 If True, attempt to include output. This will be 'real' Python
182 If True, attempt to include output. This will be 'real' Python
181 objects for the current session, or text reprs from previous
183 objects for the current session, or text reprs from previous
182 sessions if db_log_output was enabled at the time. Where no output
184 sessions if db_log_output was enabled at the time. Where no output
183 is found, None is used.
185 is found, None is used.
184
186
185 Returns
187 Returns
186 -------
188 -------
187 An iterator over the desired lines. Each line is a 3-tuple, either
189 An iterator over the desired lines. Each line is a 3-tuple, either
188 (session, line, input) if output is False, or
190 (session, line, input) if output is False, or
189 (session, line, (input, output)) if output is True.
191 (session, line, (input, output)) if output is True.
190 """
192 """
191 if session == 0 or session==self.session_number: # Current session
193 if session == 0 or session==self.session_number: # Current session
192 return self._get_hist_session(start, stop, raw, output)
194 return self._get_hist_session(start, stop, raw, output)
193 if session < 0:
195 if session < 0:
194 session += self.session_number
196 session += self.session_number
195
197
196 # Assemble the SQL query:
198 # Assemble the SQL query:
197 sqlfrom = "history"
199 sqlfrom = "history"
198 toget = "session, line, " +('source_raw' if raw else 'source')
200 toget = "session, line, " +('source_raw' if raw else 'source')
199 if output:
201 if output:
200 sqlfrom = "history LEFT JOIN output_history USING (session, line)"
202 sqlfrom = "history LEFT JOIN output_history USING (session, line)"
201 toget = "history.%s, output_history.output" % toget
203 toget = "history.%s, output_history.output" % toget
202 if stop:
204 if stop:
203 lineclause = "line >= ? AND line < ?"
205 lineclause = "line >= ? AND line < ?"
204 params = (session, start, stop)
206 params = (session, start, stop)
205 else:
207 else:
206 lineclause = "line>=?"
208 lineclause = "line>=?"
207 params = (session, start)
209 params = (session, start)
208
210
209 cur = self.db.execute("SELECT %s FROM %s WHERE session==? AND %s"\
211 cur = self.db.execute("SELECT %s FROM %s WHERE session==? AND %s"\
210 %(toget, sqlfrom, lineclause), params)
212 %(toget, sqlfrom, lineclause), params)
211 if output: # Regroup into 3-tuples
213 if output: # Regroup into 3-tuples
212 return ((ses, lin (inp, out)) for ses, lin, inp, out in cur)
214 return ((ses, lin (inp, out)) for ses, lin, inp, out in cur)
213 return cur
215 return cur
214
216
215 def get_hist_from_rangestr(self, rangestr, raw=True, output=False):
217 def get_hist_from_rangestr(self, rangestr, raw=True, output=False):
216 """Get lines of history from a string of ranges, as used by magic
218 """Get lines of history from a string of ranges, as used by magic
217 commands %hist, %save, %macro, etc."""
219 commands %hist, %save, %macro, etc."""
218 for sess, s, e in extract_hist_ranges(rangestr):
220 for sess, s, e in extract_hist_ranges(rangestr):
219 for line in self.get_history(sess, s, e, raw=raw, output=output):
221 for line in self.get_history(sess, s, e, raw=raw, output=output):
220 yield line
222 yield line
221
223
222 def store_inputs(self, line_num, source, source_raw=None):
224 def store_inputs(self, line_num, source, source_raw=None):
223 """Store source and raw input in history and create input cache
225 """Store source and raw input in history and create input cache
224 variables _i*.
226 variables _i*.
225
227
226 Parameters
228 Parameters
227 ----------
229 ----------
228 line_num : int
230 line_num : int
229 The prompt number of this input.
231 The prompt number of this input.
230
232
231 source : str
233 source : str
232 Python input.
234 Python input.
233
235
234 source_raw : str, optional
236 source_raw : str, optional
235 If given, this is the raw input without any IPython transformations
237 If given, this is the raw input without any IPython transformations
236 applied to it. If not given, ``source`` is used.
238 applied to it. If not given, ``source`` is used.
237 """
239 """
238 if source_raw is None:
240 if source_raw is None:
239 source_raw = source
241 source_raw = source
240
242
241 # do not store exit/quit commands
243 # do not store exit/quit commands
242 if source_raw.strip() in self._exit_commands:
244 if source_raw.strip() in self._exit_commands:
243 return
245 return
244
246
245 self.input_hist_parsed.append(source.rstrip())
247 self.input_hist_parsed.append(source.rstrip())
246 self.input_hist_raw.append(source_raw.rstrip())
248 self.input_hist_raw.append(source_raw.rstrip())
247
249
248 self.db_input_cache.append((self.session_number, line_num,
250 self.db_input_cache.append((self.session_number, line_num,
249 source, source_raw))
251 source, source_raw))
250 # Trigger to flush cache and write to DB.
252 # Trigger to flush cache and write to DB.
251 if len(self.db_input_cache) >= self.db_cache_size:
253 if len(self.db_input_cache) >= self.db_cache_size:
252 self.writeout_cache()
254 self.writeout_cache()
253
255
254 # update the auto _i variables
256 # update the auto _i variables
255 self._iii = self._ii
257 self._iii = self._ii
256 self._ii = self._i
258 self._ii = self._i
257 self._i = self._i00
259 self._i = self._i00
258 self._i00 = source_raw
260 self._i00 = source_raw
259
261
260 # hackish access to user namespace to create _i1,_i2... dynamically
262 # hackish access to user namespace to create _i1,_i2... dynamically
261 new_i = '_i%s' % line_num
263 new_i = '_i%s' % line_num
262 to_main = {'_i': self._i,
264 to_main = {'_i': self._i,
263 '_ii': self._ii,
265 '_ii': self._ii,
264 '_iii': self._iii,
266 '_iii': self._iii,
265 new_i : self._i00 }
267 new_i : self._i00 }
266 self.shell.user_ns.update(to_main)
268 self.shell.user_ns.update(to_main)
267
269
268 def store_output(self, line_num, output):
270 def store_output(self, line_num, output):
269 if not self.db_log_output:
271 if not self.db_log_output:
270 return
272 return
271 db_row = (self.session_number, line_num, output)
273 db_row = (self.session_number, line_num, output)
272 if self.db_cache_size > 1:
274 if self.db_cache_size > 1:
273 self.db_output_cache.append(db_row)
275 self.db_output_cache.append(db_row)
274 else:
276 else:
275 with self.db:
277 with self.db:
276 self.db.execute("INSERT INTO output_history VALUES (?,?,?)", db_row)
278 self.db.execute("INSERT INTO output_history VALUES (?,?,?)", db_row)
277
279
278 def writeout_cache(self):
280 def writeout_cache(self):
279 with self.db:
281 with self.db:
280 self.db.executemany("INSERT INTO history VALUES (?, ?, ?, ?)",
282 self.db.executemany("INSERT INTO history VALUES (?, ?, ?, ?)",
281 self.db_input_cache)
283 self.db_input_cache)
282 self.db.executemany("INSERT INTO output_history VALUES (?, ?, ?)",
284 self.db.executemany("INSERT INTO output_history VALUES (?, ?, ?)",
283 self.db_output_cache)
285 self.db_output_cache)
284 self.db_input_cache = []
286 self.db_input_cache = []
285 self.db_output_cache = []
287 self.db_output_cache = []
286
288
287 def sync_inputs(self):
289 def sync_inputs(self):
288 """Ensure raw and translated histories have same length."""
290 """Ensure raw and translated histories have same length."""
289 lr = len(self.input_hist_raw)
291 lr = len(self.input_hist_raw)
290 lp = len(self.input_hist_parsed)
292 lp = len(self.input_hist_parsed)
291 if lp < lr:
293 if lp < lr:
292 self.input_hist_raw[:lr-lp] = []
294 self.input_hist_raw[:lr-lp] = []
293 elif lr < lp:
295 elif lr < lp:
294 self.input_hist_parsed[:lp-lr] = []
296 self.input_hist_parsed[:lp-lr] = []
295
297
296 def reset(self):
298 def reset(self):
297 """Clear all histories managed by this object."""
299 """Clear all histories managed by this object, and start a new
298 self.input_hist_parsed[:] = []
300 session."""
299 self.input_hist_raw[:] = []
301 self.input_hist_parsed[:] = [""]
302 self.input_hist_raw[:] = [""]
300 self.output_hist.clear()
303 self.output_hist.clear()
301 # The directory history can't be completely empty
304 # The directory history can't be completely empty
302 self.dir_hist[:] = [os.getcwd()]
305 self.dir_hist[:] = [os.getcwd()]
303
306
307 self.writeout_cache()
308 self.init_db() # New session
309
304 # To match, e.g. ~5/8-~2/3
310 # To match, e.g. ~5/8-~2/3
305 range_re = re.compile(r"""
311 range_re = re.compile(r"""
306 ((?P<startsess>~?\d+)/)?
312 ((?P<startsess>~?\d+)/)?
307 (?P<start>\d+) # Only the start line num is compulsory
313 (?P<start>\d+) # Only the start line num is compulsory
308 ((?P<sep>[\-:])
314 ((?P<sep>[\-:])
309 ((?P<endsess>~?\d+)/)?
315 ((?P<endsess>~?\d+)/)?
310 (?P<end>\d+))?
316 (?P<end>\d+))?
311 """, re.VERBOSE)
317 """, re.VERBOSE)
312
318
313 def extract_hist_ranges(ranges_str):
319 def extract_hist_ranges(ranges_str):
314 """Turn a string of history ranges into 3-tuples of (session, start, stop).
320 """Turn a string of history ranges into 3-tuples of (session, start, stop).
315
321
316 Examples
322 Examples
317 --------
323 --------
318 list(extract_input_ranges("~8/5-~7/4 2"))
324 list(extract_input_ranges("~8/5-~7/4 2"))
319 [(-8, 5, None), (-7, 1, 4), (0, 2, 3)]
325 [(-8, 5, None), (-7, 1, 4), (0, 2, 3)]
320 """
326 """
321 for range_str in ranges_str.split():
327 for range_str in ranges_str.split():
322 rmatch = range_re.match(range_str)
328 rmatch = range_re.match(range_str)
323 start = int(rmatch.group("start"))
329 start = int(rmatch.group("start"))
324 end = rmatch.group("end")
330 end = rmatch.group("end")
325 end = int(end) if end else start+1 # If no end specified, get (a, a+1)
331 end = int(end) if end else start+1 # If no end specified, get (a, a+1)
326 if rmatch.group("sep") == "-": # 1-3 == 1:4 --> [1, 2, 3]
332 if rmatch.group("sep") == "-": # 1-3 == 1:4 --> [1, 2, 3]
327 end += 1
333 end += 1
328 startsess = rmatch.group("startsess") or "0"
334 startsess = rmatch.group("startsess") or "0"
329 endsess = rmatch.group("endsess") or startsess
335 endsess = rmatch.group("endsess") or startsess
330 startsess = int(startsess.replace("~","-"))
336 startsess = int(startsess.replace("~","-"))
331 endsess = int(endsess.replace("~","-"))
337 endsess = int(endsess.replace("~","-"))
332 assert endsess >= startsess
338 assert endsess >= startsess
333
339
334 if endsess == startsess:
340 if endsess == startsess:
335 yield (startsess, start, end)
341 yield (startsess, start, end)
336 continue
342 continue
337 # Multiple sessions in one range:
343 # Multiple sessions in one range:
338 yield (startsess, start, None)
344 yield (startsess, start, None)
339 for sess in range(startsess+1, endsess):
345 for sess in range(startsess+1, endsess):
340 yield (sess, 1, None)
346 yield (sess, 1, None)
341 yield (endsess, 1, end)
347 yield (endsess, 1, end)
342
348
343 def _format_lineno(session, line):
349 def _format_lineno(session, line):
344 """Helper function to format line numbers properly."""
350 """Helper function to format line numbers properly."""
345 if session == 0:
351 if session == 0:
346 return str(line)
352 return str(line)
347 return "%s#%s" % (session, line)
353 return "%s#%s" % (session, line)
348
354
349 @testdec.skip_doctest
355 @testdec.skip_doctest
350 def magic_history(self, parameter_s = ''):
356 def magic_history(self, parameter_s = ''):
351 """Print input history (_i<n> variables), with most recent last.
357 """Print input history (_i<n> variables), with most recent last.
352
358
353 %history -> print at most 40 inputs (some may be multi-line)\\
359 %history -> print at most 40 inputs (some may be multi-line)\\
354 %history n -> print at most n inputs\\
360 %history n -> print at most n inputs\\
355 %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
361 %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
356
362
357 By default, input history is printed without line numbers so it can be
363 By default, input history is printed without line numbers so it can be
358 directly pasted into an editor.
364 directly pasted into an editor.
359
365
360 With -n, each input's number <n> is shown, and is accessible as the
366 With -n, each input's number <n> is shown, and is accessible as the
361 automatically generated variable _i<n> as well as In[<n>]. Multi-line
367 automatically generated variable _i<n> as well as In[<n>]. Multi-line
362 statements are printed starting at a new line for easy copy/paste.
368 statements are printed starting at a new line for easy copy/paste.
363
369
364 Options:
370 Options:
365
371
366 -n: print line numbers for each input.
372 -n: print line numbers for each input.
367 This feature is only available if numbered prompts are in use.
373 This feature is only available if numbered prompts are in use.
368
374
369 -o: also print outputs for each input.
375 -o: also print outputs for each input.
370
376
371 -p: print classic '>>>' python prompts before each input. This is useful
377 -p: print classic '>>>' python prompts before each input. This is useful
372 for making documentation, and in conjunction with -o, for producing
378 for making documentation, and in conjunction with -o, for producing
373 doctest-ready output.
379 doctest-ready output.
374
380
375 -r: (default) print the 'raw' history, i.e. the actual commands you typed.
381 -r: (default) print the 'raw' history, i.e. the actual commands you typed.
376
382
377 -t: print the 'translated' history, as IPython understands it. IPython
383 -t: print the 'translated' history, as IPython understands it. IPython
378 filters your input and converts it all into valid Python source before
384 filters your input and converts it all into valid Python source before
379 executing it (things like magics or aliases are turned into function
385 executing it (things like magics or aliases are turned into function
380 calls, for example). With this option, you'll see the native history
386 calls, for example). With this option, you'll see the native history
381 instead of the user-entered version: '%cd /' will be seen as
387 instead of the user-entered version: '%cd /' will be seen as
382 'get_ipython().magic("%cd /")' instead of '%cd /'.
388 'get_ipython().magic("%cd /")' instead of '%cd /'.
383
389
384 -g: treat the arg as a pattern to grep for in (full) history.
390 -g: treat the arg as a pattern to grep for in (full) history.
385 This includes the saved history (almost all commands ever written).
391 This includes the saved history (almost all commands ever written).
386 Use '%hist -g' to show full saved history (may be very long).
392 Use '%hist -g' to show full saved history (may be very long).
387
393
388 -l: get the last n lines from all sessions. Specify n as a single arg, or
394 -l: get the last n lines from all sessions. Specify n as a single arg, or
389 the default is the last 10 lines.
395 the default is the last 10 lines.
390
396
391 -f FILENAME: instead of printing the output to the screen, redirect it to
397 -f FILENAME: instead of printing the output to the screen, redirect it to
392 the given file. The file is always overwritten, though IPython asks for
398 the given file. The file is always overwritten, though IPython asks for
393 confirmation first if it already exists.
399 confirmation first if it already exists.
394
400
395 Examples
401 Examples
396 --------
402 --------
397 ::
403 ::
398
404
399 In [6]: %hist -n 4 6
405 In [6]: %hist -n 4 6
400 4:a = 12
406 4:a = 12
401 5:print a**2
407 5:print a**2
402
408
403 """
409 """
404
410
405 if not self.shell.displayhook.do_full_cache:
411 if not self.shell.displayhook.do_full_cache:
406 print('This feature is only available if numbered prompts are in use.')
412 print('This feature is only available if numbered prompts are in use.')
407 return
413 return
408 opts,args = self.parse_options(parameter_s,'noprtglf:',mode='string')
414 opts,args = self.parse_options(parameter_s,'noprtglf:',mode='string')
409
415
410 # For brevity
416 # For brevity
411 history_manager = self.shell.history_manager
417 history_manager = self.shell.history_manager
412
418
413 # Check if output to specific file was requested.
419 # Check if output to specific file was requested.
414 try:
420 try:
415 outfname = opts['f']
421 outfname = opts['f']
416 except KeyError:
422 except KeyError:
417 outfile = IPython.utils.io.Term.cout # default
423 outfile = IPython.utils.io.Term.cout # default
418 # We don't want to close stdout at the end!
424 # We don't want to close stdout at the end!
419 close_at_end = False
425 close_at_end = False
420 else:
426 else:
421 if os.path.exists(outfname):
427 if os.path.exists(outfname):
422 if not ask_yes_no("File %r exists. Overwrite?" % outfname):
428 if not ask_yes_no("File %r exists. Overwrite?" % outfname):
423 print('Aborting.')
429 print('Aborting.')
424 return
430 return
425
431
426 outfile = open(outfname,'w')
432 outfile = open(outfname,'w')
427 close_at_end = True
433 close_at_end = True
428
434
429 print_nums = 'n' in opts
435 print_nums = 'n' in opts
430 get_output = 'o' in opts
436 get_output = 'o' in opts
431 pyprompts = 'p' in opts
437 pyprompts = 'p' in opts
432 # Raw history is the default
438 # Raw history is the default
433 raw = not('t' in opts)
439 raw = not('t' in opts)
434
440
435 default_length = 40
441 default_length = 40
436 pattern = None
442 pattern = None
437
443
438 # Glob search:
444 # Glob search:
439 if 'g' in opts:
445 if 'g' in opts:
440 pattern = "*" + args + "*" if args else "*"
446 pattern = "*" + args + "*" if args else "*"
441
447
442 # Display:
448 # Display:
443 matches_current_session = []
449 matches_current_session = []
444 for session, line, s in history_manager.get_hist_search(pattern, raw):
450 for session, line, s in history_manager.get_hist_search(pattern, raw):
445 if session == history_manager.session_number:
451 if session == history_manager.session_number:
446 matches_current_session.append(line, s)
452 matches_current_session.append(line, s)
447 continue
453 continue
448 print("%d#%d: %s" %(session, line, s.expandtabs(4)), file=outfile)
454 print("%d#%d: %s" %(session, line, s.expandtabs(4)), file=outfile)
449 if matches_current_session:
455 if matches_current_session:
450 print("=== Current session: ===", file=outfile)
456 print("=== Current session: ===", file=outfile)
451 for line, s in matches_current_session:
457 for line, s in matches_current_session:
452 print("%d: %s" %(line, s.expandtabs(4)), file=outfile)
458 print("%d: %s" %(line, s.expandtabs(4)), file=outfile)
453 return
459 return
454
460
455 if 'l' in opts: # Get 'tail'
461 if 'l' in opts: # Get 'tail'
456 try:
462 try:
457 n = int(args)
463 n = int(args)
458 except ValueError, IndexError:
464 except ValueError, IndexError:
459 n = 10
465 n = 10
460 hist = history_manager.get_hist_tail(n, raw=raw)
466 hist = history_manager.get_hist_tail(n, raw=raw)
461 else:
467 else:
462 if args: # Get history by ranges
468 if args: # Get history by ranges
463 hist = history_manager.get_hist_from_rangestr(args, raw, get_output)
469 hist = history_manager.get_hist_from_rangestr(args, raw, get_output)
464 else: # Just get history for the current session
470 else: # Just get history for the current session
465 hist = history_manager.get_history(raw=raw, output=get_output)
471 hist = history_manager.get_history(raw=raw, output=get_output)
466 # Pull hist into a list, so we can get the widest number in it.
472 # Pull hist into a list, so we can get the widest number in it.
467 hist = list(hist)
473 hist = list(hist)
468
474
469 width = max(len(_format_lineno(s, l)) for s, l, _ in hist)
475 width = max(len(_format_lineno(s, l)) for s, l, _ in hist)
470
476
471 for session, lineno, inline in hist:
477 for session, lineno, inline in hist:
472 # Print user history with tabs expanded to 4 spaces. The GUI clients
478 # Print user history with tabs expanded to 4 spaces. The GUI clients
473 # use hard tabs for easier usability in auto-indented code, but we want
479 # use hard tabs for easier usability in auto-indented code, but we want
474 # to produce PEP-8 compliant history for safe pasting into an editor.
480 # to produce PEP-8 compliant history for safe pasting into an editor.
475 if get_output:
481 if get_output:
476 inline, output = inline
482 inline, output = inline
477 inline = inline.expandtabs(4).rstrip()
483 inline = inline.expandtabs(4).rstrip()
478
484
479 if pattern is not None and not fnmatch.fnmatch(inline, pattern):
485 if pattern is not None and not fnmatch.fnmatch(inline, pattern):
480 continue
486 continue
481
487
482 multiline = "\n" in inline
488 multiline = "\n" in inline
483 line_sep = '\n' if multiline else ''
489 line_sep = '\n' if multiline else ''
484 if print_nums:
490 if print_nums:
485 print('%s:%s' % (_format_lineno(session, lineno).ljust(width),
491 print('%s:%s' % (_format_lineno(session, lineno).ljust(width),
486 line_sep[multiline]), file=outfile, end='')
492 line_sep), file=outfile, end='')
487 if pyprompts:
493 if pyprompts:
488 print(">>> ", end="", file=outfile)
494 print(">>> ", end="", file=outfile)
489 if multiline:
495 if multiline:
490 inline = "\n... ".join(inline.splitlines()) + "\n..."
496 inline = "\n... ".join(inline.splitlines()) + "\n..."
491 print(inline, file=outfile)
497 print(inline, file=outfile)
492 if get_output and output:
498 if get_output and output:
493 print(repr(output), file=outfile)
499 print(repr(output), file=outfile)
494
500
495 if close_at_end:
501 if close_at_end:
496 outfile.close()
502 outfile.close()
497
503
498 # %hist is an alternative name
504 # %hist is an alternative name
499 magic_hist = magic_history
505 magic_hist = magic_history
500
506
501
507
502 def rep_f(self, arg):
508 def rep_f(self, arg):
503 r""" Repeat a command, or get command to input line for editing
509 r""" Repeat a command, or get command to input line for editing
504
510
505 - %rep (no arguments):
511 - %rep (no arguments):
506
512
507 Place a string version of last computation result (stored in the special '_'
513 Place a string version of last computation result (stored in the special '_'
508 variable) to the next input prompt. Allows you to create elaborate command
514 variable) to the next input prompt. Allows you to create elaborate command
509 lines without using copy-paste::
515 lines without using copy-paste::
510
516
511 $ l = ["hei", "vaan"]
517 $ l = ["hei", "vaan"]
512 $ "".join(l)
518 $ "".join(l)
513 ==> heivaan
519 ==> heivaan
514 $ %rep
520 $ %rep
515 $ heivaan_ <== cursor blinking
521 $ heivaan_ <== cursor blinking
516
522
517 %rep 45
523 %rep 45
518
524
519 Place history line 45 to next input prompt. Use %hist to find out the
525 Place history line 45 to next input prompt. Use %hist to find out the
520 number.
526 number.
521
527
522 %rep 1-4 6-7 3
528 %rep 1-4 6-7 3
523
529
524 Repeat the specified lines immediately. Input slice syntax is the same as
530 Repeat the specified lines immediately. Input slice syntax is the same as
525 in %macro and %save.
531 in %macro and %save.
526
532
527 %rep foo
533 %rep foo
528
534
529 Place the most recent line that has the substring "foo" to next input.
535 Place the most recent line that has the substring "foo" to next input.
530 (e.g. 'svn ci -m foobar').
536 (e.g. 'svn ci -m foobar').
531 """
537 """
532
538
533 opts,args = self.parse_options(arg,'',mode='list')
539 opts,args = self.parse_options(arg,'',mode='list')
534 if not args:
540 if not args:
535 self.set_next_input(str(self.shell.user_ns["_"]))
541 self.set_next_input(str(self.shell.user_ns["_"]))
536 return
542 return
537
543
538 if len(args) == 1 and not '-' in args[0]:
544 if len(args) == 1 and not '-' in args[0]:
539 arg = args[0]
545 arg = args[0]
540 if len(arg) > 1 and arg.startswith('0'):
546 if len(arg) > 1 and arg.startswith('0'):
541 # get from shadow hist
547 # get from shadow hist
542 num = int(arg[1:])
548 num = int(arg[1:])
543 line = self.shell.shadowhist.get(num)
549 line = self.shell.shadowhist.get(num)
544 self.set_next_input(str(line))
550 self.set_next_input(str(line))
545 return
551 return
546 try:
552 try:
547 num = int(args[0])
553 num = int(args[0])
548 self.set_next_input(str(self.shell.input_hist_raw[num]).rstrip())
554 self.set_next_input(str(self.shell.input_hist_raw[num]).rstrip())
549 return
555 return
550 except ValueError:
556 except ValueError:
551 pass
557 pass
552
558
553 for h in reversed(self.shell.input_hist_raw):
559 for h in reversed(self.shell.input_hist_raw):
554 if 'rep' in h:
560 if 'rep' in h:
555 continue
561 continue
556 if fnmatch.fnmatch(h,'*' + arg + '*'):
562 if fnmatch.fnmatch(h,'*' + arg + '*'):
557 self.set_next_input(str(h).rstrip())
563 self.set_next_input(str(h).rstrip())
558 return
564 return
559
565
560 try:
566 try:
561 lines = self.extract_input_slices(args, True)
567 lines = self.extract_input_slices(args, True)
562 print("lines", lines)
568 print("lines", lines)
563 self.run_cell(lines)
569 self.run_cell(lines)
564 except ValueError:
570 except ValueError:
565 print("Not found in recent history:", args)
571 print("Not found in recent history:", args)
566
572
567
573
568 def init_ipython(ip):
574 def init_ipython(ip):
569 ip.define_magic("rep",rep_f)
575 ip.define_magic("rep",rep_f)
570 ip.define_magic("hist",magic_hist)
576 ip.define_magic("hist",magic_hist)
571 ip.define_magic("history",magic_history)
577 ip.define_magic("history",magic_history)
572
578
573 # XXX - ipy_completers are in quarantine, need to be updated to new apis
579 # XXX - ipy_completers are in quarantine, need to be updated to new apis
574 #import ipy_completers
580 #import ipy_completers
575 #ipy_completers.quick_completer('%hist' ,'-g -t -r -n')
581 #ipy_completers.quick_completer('%hist' ,'-g -t -r -n')
@@ -1,3489 +1,3489 b''
1 # encoding: utf-8
1 # encoding: utf-8
2 """Magic functions for InteractiveShell.
2 """Magic functions for InteractiveShell.
3 """
3 """
4
4
5 #-----------------------------------------------------------------------------
5 #-----------------------------------------------------------------------------
6 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
6 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
7 # Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
7 # Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
8 # Copyright (C) 2008-2009 The IPython Development Team
8 # Copyright (C) 2008-2009 The IPython Development Team
9
9
10 # Distributed under the terms of the BSD License. The full license is in
10 # Distributed under the terms of the BSD License. The full license is in
11 # the file COPYING, distributed as part of this software.
11 # the file COPYING, distributed as part of this software.
12 #-----------------------------------------------------------------------------
12 #-----------------------------------------------------------------------------
13
13
14 #-----------------------------------------------------------------------------
14 #-----------------------------------------------------------------------------
15 # Imports
15 # Imports
16 #-----------------------------------------------------------------------------
16 #-----------------------------------------------------------------------------
17
17
18 import __builtin__
18 import __builtin__
19 import __future__
19 import __future__
20 import bdb
20 import bdb
21 import inspect
21 import inspect
22 import os
22 import os
23 import sys
23 import sys
24 import shutil
24 import shutil
25 import re
25 import re
26 import time
26 import time
27 import textwrap
27 import textwrap
28 import types
28 import types
29 from cStringIO import StringIO
29 from cStringIO import StringIO
30 from getopt import getopt,GetoptError
30 from getopt import getopt,GetoptError
31 from pprint import pformat
31 from pprint import pformat
32
32
33 # cProfile was added in Python2.5
33 # cProfile was added in Python2.5
34 try:
34 try:
35 import cProfile as profile
35 import cProfile as profile
36 import pstats
36 import pstats
37 except ImportError:
37 except ImportError:
38 # profile isn't bundled by default in Debian for license reasons
38 # profile isn't bundled by default in Debian for license reasons
39 try:
39 try:
40 import profile,pstats
40 import profile,pstats
41 except ImportError:
41 except ImportError:
42 profile = pstats = None
42 profile = pstats = None
43
43
44 import IPython
44 import IPython
45 from IPython.core import debugger, oinspect
45 from IPython.core import debugger, oinspect
46 from IPython.core.error import TryNext
46 from IPython.core.error import TryNext
47 from IPython.core.error import UsageError
47 from IPython.core.error import UsageError
48 from IPython.core.fakemodule import FakeModule
48 from IPython.core.fakemodule import FakeModule
49 from IPython.core.macro import Macro
49 from IPython.core.macro import Macro
50 from IPython.core import page
50 from IPython.core import page
51 from IPython.core.prefilter import ESC_MAGIC
51 from IPython.core.prefilter import ESC_MAGIC
52 from IPython.lib.pylabtools import mpl_runner
52 from IPython.lib.pylabtools import mpl_runner
53 from IPython.external.Itpl import itpl, printpl
53 from IPython.external.Itpl import itpl, printpl
54 from IPython.testing import decorators as testdec
54 from IPython.testing import decorators as testdec
55 from IPython.utils.io import file_read, nlprint
55 from IPython.utils.io import file_read, nlprint
56 import IPython.utils.io
56 import IPython.utils.io
57 from IPython.utils.path import get_py_filename
57 from IPython.utils.path import get_py_filename
58 from IPython.utils.process import arg_split, abbrev_cwd
58 from IPython.utils.process import arg_split, abbrev_cwd
59 from IPython.utils.terminal import set_term_title
59 from IPython.utils.terminal import set_term_title
60 from IPython.utils.text import LSString, SList, format_screen
60 from IPython.utils.text import LSString, SList, format_screen
61 from IPython.utils.timing import clock, clock2
61 from IPython.utils.timing import clock, clock2
62 from IPython.utils.warn import warn, error
62 from IPython.utils.warn import warn, error
63 from IPython.utils.ipstruct import Struct
63 from IPython.utils.ipstruct import Struct
64 import IPython.utils.generics
64 import IPython.utils.generics
65
65
66 #-----------------------------------------------------------------------------
66 #-----------------------------------------------------------------------------
67 # Utility functions
67 # Utility functions
68 #-----------------------------------------------------------------------------
68 #-----------------------------------------------------------------------------
69
69
70 def on_off(tag):
70 def on_off(tag):
71 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
71 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
72 return ['OFF','ON'][tag]
72 return ['OFF','ON'][tag]
73
73
74 class Bunch: pass
74 class Bunch: pass
75
75
76 def compress_dhist(dh):
76 def compress_dhist(dh):
77 head, tail = dh[:-10], dh[-10:]
77 head, tail = dh[:-10], dh[-10:]
78
78
79 newhead = []
79 newhead = []
80 done = set()
80 done = set()
81 for h in head:
81 for h in head:
82 if h in done:
82 if h in done:
83 continue
83 continue
84 newhead.append(h)
84 newhead.append(h)
85 done.add(h)
85 done.add(h)
86
86
87 return newhead + tail
87 return newhead + tail
88
88
89
89
90 #***************************************************************************
90 #***************************************************************************
91 # Main class implementing Magic functionality
91 # Main class implementing Magic functionality
92
92
93 # XXX - for some odd reason, if Magic is made a new-style class, we get errors
93 # XXX - for some odd reason, if Magic is made a new-style class, we get errors
94 # on construction of the main InteractiveShell object. Something odd is going
94 # on construction of the main InteractiveShell object. Something odd is going
95 # on with super() calls, Configurable and the MRO... For now leave it as-is, but
95 # on with super() calls, Configurable and the MRO... For now leave it as-is, but
96 # eventually this needs to be clarified.
96 # eventually this needs to be clarified.
97 # BG: This is because InteractiveShell inherits from this, but is itself a
97 # BG: This is because InteractiveShell inherits from this, but is itself a
98 # Configurable. This messes up the MRO in some way. The fix is that we need to
98 # Configurable. This messes up the MRO in some way. The fix is that we need to
99 # make Magic a configurable that InteractiveShell does not subclass.
99 # make Magic a configurable that InteractiveShell does not subclass.
100
100
101 class Magic:
101 class Magic:
102 """Magic functions for InteractiveShell.
102 """Magic functions for InteractiveShell.
103
103
104 Shell functions which can be reached as %function_name. All magic
104 Shell functions which can be reached as %function_name. All magic
105 functions should accept a string, which they can parse for their own
105 functions should accept a string, which they can parse for their own
106 needs. This can make some functions easier to type, eg `%cd ../`
106 needs. This can make some functions easier to type, eg `%cd ../`
107 vs. `%cd("../")`
107 vs. `%cd("../")`
108
108
109 ALL definitions MUST begin with the prefix magic_. The user won't need it
109 ALL definitions MUST begin with the prefix magic_. The user won't need it
110 at the command line, but it is is needed in the definition. """
110 at the command line, but it is is needed in the definition. """
111
111
112 # class globals
112 # class globals
113 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
113 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
114 'Automagic is ON, % prefix NOT needed for magic functions.']
114 'Automagic is ON, % prefix NOT needed for magic functions.']
115
115
116 #......................................................................
116 #......................................................................
117 # some utility functions
117 # some utility functions
118
118
119 def __init__(self,shell):
119 def __init__(self,shell):
120
120
121 self.options_table = {}
121 self.options_table = {}
122 if profile is None:
122 if profile is None:
123 self.magic_prun = self.profile_missing_notice
123 self.magic_prun = self.profile_missing_notice
124 self.shell = shell
124 self.shell = shell
125
125
126 # namespace for holding state we may need
126 # namespace for holding state we may need
127 self._magic_state = Bunch()
127 self._magic_state = Bunch()
128
128
129 def profile_missing_notice(self, *args, **kwargs):
129 def profile_missing_notice(self, *args, **kwargs):
130 error("""\
130 error("""\
131 The profile module could not be found. It has been removed from the standard
131 The profile module could not be found. It has been removed from the standard
132 python packages because of its non-free license. To use profiling, install the
132 python packages because of its non-free license. To use profiling, install the
133 python-profiler package from non-free.""")
133 python-profiler package from non-free.""")
134
134
135 def default_option(self,fn,optstr):
135 def default_option(self,fn,optstr):
136 """Make an entry in the options_table for fn, with value optstr"""
136 """Make an entry in the options_table for fn, with value optstr"""
137
137
138 if fn not in self.lsmagic():
138 if fn not in self.lsmagic():
139 error("%s is not a magic function" % fn)
139 error("%s is not a magic function" % fn)
140 self.options_table[fn] = optstr
140 self.options_table[fn] = optstr
141
141
142 def lsmagic(self):
142 def lsmagic(self):
143 """Return a list of currently available magic functions.
143 """Return a list of currently available magic functions.
144
144
145 Gives a list of the bare names after mangling (['ls','cd', ...], not
145 Gives a list of the bare names after mangling (['ls','cd', ...], not
146 ['magic_ls','magic_cd',...]"""
146 ['magic_ls','magic_cd',...]"""
147
147
148 # FIXME. This needs a cleanup, in the way the magics list is built.
148 # FIXME. This needs a cleanup, in the way the magics list is built.
149
149
150 # magics in class definition
150 # magics in class definition
151 class_magic = lambda fn: fn.startswith('magic_') and \
151 class_magic = lambda fn: fn.startswith('magic_') and \
152 callable(Magic.__dict__[fn])
152 callable(Magic.__dict__[fn])
153 # in instance namespace (run-time user additions)
153 # in instance namespace (run-time user additions)
154 inst_magic = lambda fn: fn.startswith('magic_') and \
154 inst_magic = lambda fn: fn.startswith('magic_') and \
155 callable(self.__dict__[fn])
155 callable(self.__dict__[fn])
156 # and bound magics by user (so they can access self):
156 # and bound magics by user (so they can access self):
157 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
157 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
158 callable(self.__class__.__dict__[fn])
158 callable(self.__class__.__dict__[fn])
159 magics = filter(class_magic,Magic.__dict__.keys()) + \
159 magics = filter(class_magic,Magic.__dict__.keys()) + \
160 filter(inst_magic,self.__dict__.keys()) + \
160 filter(inst_magic,self.__dict__.keys()) + \
161 filter(inst_bound_magic,self.__class__.__dict__.keys())
161 filter(inst_bound_magic,self.__class__.__dict__.keys())
162 out = []
162 out = []
163 for fn in set(magics):
163 for fn in set(magics):
164 out.append(fn.replace('magic_','',1))
164 out.append(fn.replace('magic_','',1))
165 out.sort()
165 out.sort()
166 return out
166 return out
167
167
168 def extract_input_lines(self, range_str, raw=False):
168 def extract_input_lines(self, range_str, raw=False):
169 """Return as a string a set of input history slices.
169 """Return as a string a set of input history slices.
170
170
171 Inputs:
171 Inputs:
172
172
173 - range_str: the set of slices is given as a string, like
173 - range_str: the set of slices is given as a string, like
174 "~5#6-~4#2 4:8 9", since this function is for use by magic functions
174 "~5#6-~4#2 4:8 9", since this function is for use by magic functions
175 which get their arguments as strings. The number before the # is the
175 which get their arguments as strings. The number before the # is the
176 session number: ~n goes n back from the current session.
176 session number: ~n goes n back from the current session.
177
177
178 Optional inputs:
178 Optional inputs:
179
179
180 - raw(False): by default, the processed input is used. If this is
180 - raw(False): by default, the processed input is used. If this is
181 true, the raw input history is used instead.
181 true, the raw input history is used instead.
182
182
183 Note that slices can be called with two notations:
183 Note that slices can be called with two notations:
184
184
185 N:M -> standard python form, means including items N...(M-1).
185 N:M -> standard python form, means including items N...(M-1).
186
186
187 N-M -> include items N..M (closed endpoint)."""
187 N-M -> include items N..M (closed endpoint)."""
188 lines = self.shell.history_manager.\
188 lines = self.shell.history_manager.\
189 get_hist_from_rangestr(range_str, raw=raw)
189 get_hist_from_rangestr(range_str, raw=raw)
190 return "\n".join(x for _, _, x in lines)
190 return "\n".join(x for _, _, x in lines)
191
191
192 def arg_err(self,func):
192 def arg_err(self,func):
193 """Print docstring if incorrect arguments were passed"""
193 """Print docstring if incorrect arguments were passed"""
194 print 'Error in arguments:'
194 print 'Error in arguments:'
195 print oinspect.getdoc(func)
195 print oinspect.getdoc(func)
196
196
197 def format_latex(self,strng):
197 def format_latex(self,strng):
198 """Format a string for latex inclusion."""
198 """Format a string for latex inclusion."""
199
199
200 # Characters that need to be escaped for latex:
200 # Characters that need to be escaped for latex:
201 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
201 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
202 # Magic command names as headers:
202 # Magic command names as headers:
203 cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
203 cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
204 re.MULTILINE)
204 re.MULTILINE)
205 # Magic commands
205 # Magic commands
206 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
206 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
207 re.MULTILINE)
207 re.MULTILINE)
208 # Paragraph continue
208 # Paragraph continue
209 par_re = re.compile(r'\\$',re.MULTILINE)
209 par_re = re.compile(r'\\$',re.MULTILINE)
210
210
211 # The "\n" symbol
211 # The "\n" symbol
212 newline_re = re.compile(r'\\n')
212 newline_re = re.compile(r'\\n')
213
213
214 # Now build the string for output:
214 # Now build the string for output:
215 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
215 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
216 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
216 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
217 strng)
217 strng)
218 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
218 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
219 strng = par_re.sub(r'\\\\',strng)
219 strng = par_re.sub(r'\\\\',strng)
220 strng = escape_re.sub(r'\\\1',strng)
220 strng = escape_re.sub(r'\\\1',strng)
221 strng = newline_re.sub(r'\\textbackslash{}n',strng)
221 strng = newline_re.sub(r'\\textbackslash{}n',strng)
222 return strng
222 return strng
223
223
224 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
224 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
225 """Parse options passed to an argument string.
225 """Parse options passed to an argument string.
226
226
227 The interface is similar to that of getopt(), but it returns back a
227 The interface is similar to that of getopt(), but it returns back a
228 Struct with the options as keys and the stripped argument string still
228 Struct with the options as keys and the stripped argument string still
229 as a string.
229 as a string.
230
230
231 arg_str is quoted as a true sys.argv vector by using shlex.split.
231 arg_str is quoted as a true sys.argv vector by using shlex.split.
232 This allows us to easily expand variables, glob files, quote
232 This allows us to easily expand variables, glob files, quote
233 arguments, etc.
233 arguments, etc.
234
234
235 Options:
235 Options:
236 -mode: default 'string'. If given as 'list', the argument string is
236 -mode: default 'string'. If given as 'list', the argument string is
237 returned as a list (split on whitespace) instead of a string.
237 returned as a list (split on whitespace) instead of a string.
238
238
239 -list_all: put all option values in lists. Normally only options
239 -list_all: put all option values in lists. Normally only options
240 appearing more than once are put in a list.
240 appearing more than once are put in a list.
241
241
242 -posix (True): whether to split the input line in POSIX mode or not,
242 -posix (True): whether to split the input line in POSIX mode or not,
243 as per the conventions outlined in the shlex module from the
243 as per the conventions outlined in the shlex module from the
244 standard library."""
244 standard library."""
245
245
246 # inject default options at the beginning of the input line
246 # inject default options at the beginning of the input line
247 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
247 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
248 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
248 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
249
249
250 mode = kw.get('mode','string')
250 mode = kw.get('mode','string')
251 if mode not in ['string','list']:
251 if mode not in ['string','list']:
252 raise ValueError,'incorrect mode given: %s' % mode
252 raise ValueError,'incorrect mode given: %s' % mode
253 # Get options
253 # Get options
254 list_all = kw.get('list_all',0)
254 list_all = kw.get('list_all',0)
255 posix = kw.get('posix', os.name == 'posix')
255 posix = kw.get('posix', os.name == 'posix')
256
256
257 # Check if we have more than one argument to warrant extra processing:
257 # Check if we have more than one argument to warrant extra processing:
258 odict = {} # Dictionary with options
258 odict = {} # Dictionary with options
259 args = arg_str.split()
259 args = arg_str.split()
260 if len(args) >= 1:
260 if len(args) >= 1:
261 # If the list of inputs only has 0 or 1 thing in it, there's no
261 # If the list of inputs only has 0 or 1 thing in it, there's no
262 # need to look for options
262 # need to look for options
263 argv = arg_split(arg_str,posix)
263 argv = arg_split(arg_str,posix)
264 # Do regular option processing
264 # Do regular option processing
265 try:
265 try:
266 opts,args = getopt(argv,opt_str,*long_opts)
266 opts,args = getopt(argv,opt_str,*long_opts)
267 except GetoptError,e:
267 except GetoptError,e:
268 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
268 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
269 " ".join(long_opts)))
269 " ".join(long_opts)))
270 for o,a in opts:
270 for o,a in opts:
271 if o.startswith('--'):
271 if o.startswith('--'):
272 o = o[2:]
272 o = o[2:]
273 else:
273 else:
274 o = o[1:]
274 o = o[1:]
275 try:
275 try:
276 odict[o].append(a)
276 odict[o].append(a)
277 except AttributeError:
277 except AttributeError:
278 odict[o] = [odict[o],a]
278 odict[o] = [odict[o],a]
279 except KeyError:
279 except KeyError:
280 if list_all:
280 if list_all:
281 odict[o] = [a]
281 odict[o] = [a]
282 else:
282 else:
283 odict[o] = a
283 odict[o] = a
284
284
285 # Prepare opts,args for return
285 # Prepare opts,args for return
286 opts = Struct(odict)
286 opts = Struct(odict)
287 if mode == 'string':
287 if mode == 'string':
288 args = ' '.join(args)
288 args = ' '.join(args)
289
289
290 return opts,args
290 return opts,args
291
291
292 #......................................................................
292 #......................................................................
293 # And now the actual magic functions
293 # And now the actual magic functions
294
294
295 # Functions for IPython shell work (vars,funcs, config, etc)
295 # Functions for IPython shell work (vars,funcs, config, etc)
296 def magic_lsmagic(self, parameter_s = ''):
296 def magic_lsmagic(self, parameter_s = ''):
297 """List currently available magic functions."""
297 """List currently available magic functions."""
298 mesc = ESC_MAGIC
298 mesc = ESC_MAGIC
299 print 'Available magic functions:\n'+mesc+\
299 print 'Available magic functions:\n'+mesc+\
300 (' '+mesc).join(self.lsmagic())
300 (' '+mesc).join(self.lsmagic())
301 print '\n' + Magic.auto_status[self.shell.automagic]
301 print '\n' + Magic.auto_status[self.shell.automagic]
302 return None
302 return None
303
303
304 def magic_magic(self, parameter_s = ''):
304 def magic_magic(self, parameter_s = ''):
305 """Print information about the magic function system.
305 """Print information about the magic function system.
306
306
307 Supported formats: -latex, -brief, -rest
307 Supported formats: -latex, -brief, -rest
308 """
308 """
309
309
310 mode = ''
310 mode = ''
311 try:
311 try:
312 if parameter_s.split()[0] == '-latex':
312 if parameter_s.split()[0] == '-latex':
313 mode = 'latex'
313 mode = 'latex'
314 if parameter_s.split()[0] == '-brief':
314 if parameter_s.split()[0] == '-brief':
315 mode = 'brief'
315 mode = 'brief'
316 if parameter_s.split()[0] == '-rest':
316 if parameter_s.split()[0] == '-rest':
317 mode = 'rest'
317 mode = 'rest'
318 rest_docs = []
318 rest_docs = []
319 except:
319 except:
320 pass
320 pass
321
321
322 magic_docs = []
322 magic_docs = []
323 for fname in self.lsmagic():
323 for fname in self.lsmagic():
324 mname = 'magic_' + fname
324 mname = 'magic_' + fname
325 for space in (Magic,self,self.__class__):
325 for space in (Magic,self,self.__class__):
326 try:
326 try:
327 fn = space.__dict__[mname]
327 fn = space.__dict__[mname]
328 except KeyError:
328 except KeyError:
329 pass
329 pass
330 else:
330 else:
331 break
331 break
332 if mode == 'brief':
332 if mode == 'brief':
333 # only first line
333 # only first line
334 if fn.__doc__:
334 if fn.__doc__:
335 fndoc = fn.__doc__.split('\n',1)[0]
335 fndoc = fn.__doc__.split('\n',1)[0]
336 else:
336 else:
337 fndoc = 'No documentation'
337 fndoc = 'No documentation'
338 else:
338 else:
339 if fn.__doc__:
339 if fn.__doc__:
340 fndoc = fn.__doc__.rstrip()
340 fndoc = fn.__doc__.rstrip()
341 else:
341 else:
342 fndoc = 'No documentation'
342 fndoc = 'No documentation'
343
343
344
344
345 if mode == 'rest':
345 if mode == 'rest':
346 rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
346 rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
347 fname,fndoc))
347 fname,fndoc))
348
348
349 else:
349 else:
350 magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
350 magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
351 fname,fndoc))
351 fname,fndoc))
352
352
353 magic_docs = ''.join(magic_docs)
353 magic_docs = ''.join(magic_docs)
354
354
355 if mode == 'rest':
355 if mode == 'rest':
356 return "".join(rest_docs)
356 return "".join(rest_docs)
357
357
358 if mode == 'latex':
358 if mode == 'latex':
359 print self.format_latex(magic_docs)
359 print self.format_latex(magic_docs)
360 return
360 return
361 else:
361 else:
362 magic_docs = format_screen(magic_docs)
362 magic_docs = format_screen(magic_docs)
363 if mode == 'brief':
363 if mode == 'brief':
364 return magic_docs
364 return magic_docs
365
365
366 outmsg = """
366 outmsg = """
367 IPython's 'magic' functions
367 IPython's 'magic' functions
368 ===========================
368 ===========================
369
369
370 The magic function system provides a series of functions which allow you to
370 The magic function system provides a series of functions which allow you to
371 control the behavior of IPython itself, plus a lot of system-type
371 control the behavior of IPython itself, plus a lot of system-type
372 features. All these functions are prefixed with a % character, but parameters
372 features. All these functions are prefixed with a % character, but parameters
373 are given without parentheses or quotes.
373 are given without parentheses or quotes.
374
374
375 NOTE: If you have 'automagic' enabled (via the command line option or with the
375 NOTE: If you have 'automagic' enabled (via the command line option or with the
376 %automagic function), you don't need to type in the % explicitly. By default,
376 %automagic function), you don't need to type in the % explicitly. By default,
377 IPython ships with automagic on, so you should only rarely need the % escape.
377 IPython ships with automagic on, so you should only rarely need the % escape.
378
378
379 Example: typing '%cd mydir' (without the quotes) changes you working directory
379 Example: typing '%cd mydir' (without the quotes) changes you working directory
380 to 'mydir', if it exists.
380 to 'mydir', if it exists.
381
381
382 You can define your own magic functions to extend the system. See the supplied
382 You can define your own magic functions to extend the system. See the supplied
383 ipythonrc and example-magic.py files for details (in your ipython
383 ipythonrc and example-magic.py files for details (in your ipython
384 configuration directory, typically $HOME/.config/ipython on Linux or $HOME/.ipython elsewhere).
384 configuration directory, typically $HOME/.config/ipython on Linux or $HOME/.ipython elsewhere).
385
385
386 You can also define your own aliased names for magic functions. In your
386 You can also define your own aliased names for magic functions. In your
387 ipythonrc file, placing a line like:
387 ipythonrc file, placing a line like:
388
388
389 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
389 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
390
390
391 will define %pf as a new name for %profile.
391 will define %pf as a new name for %profile.
392
392
393 You can also call magics in code using the magic() function, which IPython
393 You can also call magics in code using the magic() function, which IPython
394 automatically adds to the builtin namespace. Type 'magic?' for details.
394 automatically adds to the builtin namespace. Type 'magic?' for details.
395
395
396 For a list of the available magic functions, use %lsmagic. For a description
396 For a list of the available magic functions, use %lsmagic. For a description
397 of any of them, type %magic_name?, e.g. '%cd?'.
397 of any of them, type %magic_name?, e.g. '%cd?'.
398
398
399 Currently the magic system has the following functions:\n"""
399 Currently the magic system has the following functions:\n"""
400
400
401 mesc = ESC_MAGIC
401 mesc = ESC_MAGIC
402 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
402 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
403 "\n\n%s%s\n\n%s" % (outmsg,
403 "\n\n%s%s\n\n%s" % (outmsg,
404 magic_docs,mesc,mesc,
404 magic_docs,mesc,mesc,
405 (' '+mesc).join(self.lsmagic()),
405 (' '+mesc).join(self.lsmagic()),
406 Magic.auto_status[self.shell.automagic] ) )
406 Magic.auto_status[self.shell.automagic] ) )
407 page.page(outmsg)
407 page.page(outmsg)
408
408
409 def magic_automagic(self, parameter_s = ''):
409 def magic_automagic(self, parameter_s = ''):
410 """Make magic functions callable without having to type the initial %.
410 """Make magic functions callable without having to type the initial %.
411
411
412 Without argumentsl toggles on/off (when off, you must call it as
412 Without argumentsl toggles on/off (when off, you must call it as
413 %automagic, of course). With arguments it sets the value, and you can
413 %automagic, of course). With arguments it sets the value, and you can
414 use any of (case insensitive):
414 use any of (case insensitive):
415
415
416 - on,1,True: to activate
416 - on,1,True: to activate
417
417
418 - off,0,False: to deactivate.
418 - off,0,False: to deactivate.
419
419
420 Note that magic functions have lowest priority, so if there's a
420 Note that magic functions have lowest priority, so if there's a
421 variable whose name collides with that of a magic fn, automagic won't
421 variable whose name collides with that of a magic fn, automagic won't
422 work for that function (you get the variable instead). However, if you
422 work for that function (you get the variable instead). However, if you
423 delete the variable (del var), the previously shadowed magic function
423 delete the variable (del var), the previously shadowed magic function
424 becomes visible to automagic again."""
424 becomes visible to automagic again."""
425
425
426 arg = parameter_s.lower()
426 arg = parameter_s.lower()
427 if parameter_s in ('on','1','true'):
427 if parameter_s in ('on','1','true'):
428 self.shell.automagic = True
428 self.shell.automagic = True
429 elif parameter_s in ('off','0','false'):
429 elif parameter_s in ('off','0','false'):
430 self.shell.automagic = False
430 self.shell.automagic = False
431 else:
431 else:
432 self.shell.automagic = not self.shell.automagic
432 self.shell.automagic = not self.shell.automagic
433 print '\n' + Magic.auto_status[self.shell.automagic]
433 print '\n' + Magic.auto_status[self.shell.automagic]
434
434
435 @testdec.skip_doctest
435 @testdec.skip_doctest
436 def magic_autocall(self, parameter_s = ''):
436 def magic_autocall(self, parameter_s = ''):
437 """Make functions callable without having to type parentheses.
437 """Make functions callable without having to type parentheses.
438
438
439 Usage:
439 Usage:
440
440
441 %autocall [mode]
441 %autocall [mode]
442
442
443 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
443 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
444 value is toggled on and off (remembering the previous state).
444 value is toggled on and off (remembering the previous state).
445
445
446 In more detail, these values mean:
446 In more detail, these values mean:
447
447
448 0 -> fully disabled
448 0 -> fully disabled
449
449
450 1 -> active, but do not apply if there are no arguments on the line.
450 1 -> active, but do not apply if there are no arguments on the line.
451
451
452 In this mode, you get:
452 In this mode, you get:
453
453
454 In [1]: callable
454 In [1]: callable
455 Out[1]: <built-in function callable>
455 Out[1]: <built-in function callable>
456
456
457 In [2]: callable 'hello'
457 In [2]: callable 'hello'
458 ------> callable('hello')
458 ------> callable('hello')
459 Out[2]: False
459 Out[2]: False
460
460
461 2 -> Active always. Even if no arguments are present, the callable
461 2 -> Active always. Even if no arguments are present, the callable
462 object is called:
462 object is called:
463
463
464 In [2]: float
464 In [2]: float
465 ------> float()
465 ------> float()
466 Out[2]: 0.0
466 Out[2]: 0.0
467
467
468 Note that even with autocall off, you can still use '/' at the start of
468 Note that even with autocall off, you can still use '/' at the start of
469 a line to treat the first argument on the command line as a function
469 a line to treat the first argument on the command line as a function
470 and add parentheses to it:
470 and add parentheses to it:
471
471
472 In [8]: /str 43
472 In [8]: /str 43
473 ------> str(43)
473 ------> str(43)
474 Out[8]: '43'
474 Out[8]: '43'
475
475
476 # all-random (note for auto-testing)
476 # all-random (note for auto-testing)
477 """
477 """
478
478
479 if parameter_s:
479 if parameter_s:
480 arg = int(parameter_s)
480 arg = int(parameter_s)
481 else:
481 else:
482 arg = 'toggle'
482 arg = 'toggle'
483
483
484 if not arg in (0,1,2,'toggle'):
484 if not arg in (0,1,2,'toggle'):
485 error('Valid modes: (0->Off, 1->Smart, 2->Full')
485 error('Valid modes: (0->Off, 1->Smart, 2->Full')
486 return
486 return
487
487
488 if arg in (0,1,2):
488 if arg in (0,1,2):
489 self.shell.autocall = arg
489 self.shell.autocall = arg
490 else: # toggle
490 else: # toggle
491 if self.shell.autocall:
491 if self.shell.autocall:
492 self._magic_state.autocall_save = self.shell.autocall
492 self._magic_state.autocall_save = self.shell.autocall
493 self.shell.autocall = 0
493 self.shell.autocall = 0
494 else:
494 else:
495 try:
495 try:
496 self.shell.autocall = self._magic_state.autocall_save
496 self.shell.autocall = self._magic_state.autocall_save
497 except AttributeError:
497 except AttributeError:
498 self.shell.autocall = self._magic_state.autocall_save = 1
498 self.shell.autocall = self._magic_state.autocall_save = 1
499
499
500 print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
500 print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
501
501
502
502
503 def magic_page(self, parameter_s=''):
503 def magic_page(self, parameter_s=''):
504 """Pretty print the object and display it through a pager.
504 """Pretty print the object and display it through a pager.
505
505
506 %page [options] OBJECT
506 %page [options] OBJECT
507
507
508 If no object is given, use _ (last output).
508 If no object is given, use _ (last output).
509
509
510 Options:
510 Options:
511
511
512 -r: page str(object), don't pretty-print it."""
512 -r: page str(object), don't pretty-print it."""
513
513
514 # After a function contributed by Olivier Aubert, slightly modified.
514 # After a function contributed by Olivier Aubert, slightly modified.
515
515
516 # Process options/args
516 # Process options/args
517 opts,args = self.parse_options(parameter_s,'r')
517 opts,args = self.parse_options(parameter_s,'r')
518 raw = 'r' in opts
518 raw = 'r' in opts
519
519
520 oname = args and args or '_'
520 oname = args and args or '_'
521 info = self._ofind(oname)
521 info = self._ofind(oname)
522 if info['found']:
522 if info['found']:
523 txt = (raw and str or pformat)( info['obj'] )
523 txt = (raw and str or pformat)( info['obj'] )
524 page.page(txt)
524 page.page(txt)
525 else:
525 else:
526 print 'Object `%s` not found' % oname
526 print 'Object `%s` not found' % oname
527
527
528 def magic_profile(self, parameter_s=''):
528 def magic_profile(self, parameter_s=''):
529 """Print your currently active IPython profile."""
529 """Print your currently active IPython profile."""
530 if self.shell.profile:
530 if self.shell.profile:
531 printpl('Current IPython profile: $self.shell.profile.')
531 printpl('Current IPython profile: $self.shell.profile.')
532 else:
532 else:
533 print 'No profile active.'
533 print 'No profile active.'
534
534
535 def magic_pinfo(self, parameter_s='', namespaces=None):
535 def magic_pinfo(self, parameter_s='', namespaces=None):
536 """Provide detailed information about an object.
536 """Provide detailed information about an object.
537
537
538 '%pinfo object' is just a synonym for object? or ?object."""
538 '%pinfo object' is just a synonym for object? or ?object."""
539
539
540 #print 'pinfo par: <%s>' % parameter_s # dbg
540 #print 'pinfo par: <%s>' % parameter_s # dbg
541
541
542
542
543 # detail_level: 0 -> obj? , 1 -> obj??
543 # detail_level: 0 -> obj? , 1 -> obj??
544 detail_level = 0
544 detail_level = 0
545 # We need to detect if we got called as 'pinfo pinfo foo', which can
545 # We need to detect if we got called as 'pinfo pinfo foo', which can
546 # happen if the user types 'pinfo foo?' at the cmd line.
546 # happen if the user types 'pinfo foo?' at the cmd line.
547 pinfo,qmark1,oname,qmark2 = \
547 pinfo,qmark1,oname,qmark2 = \
548 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
548 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
549 if pinfo or qmark1 or qmark2:
549 if pinfo or qmark1 or qmark2:
550 detail_level = 1
550 detail_level = 1
551 if "*" in oname:
551 if "*" in oname:
552 self.magic_psearch(oname)
552 self.magic_psearch(oname)
553 else:
553 else:
554 self.shell._inspect('pinfo', oname, detail_level=detail_level,
554 self.shell._inspect('pinfo', oname, detail_level=detail_level,
555 namespaces=namespaces)
555 namespaces=namespaces)
556
556
557 def magic_pinfo2(self, parameter_s='', namespaces=None):
557 def magic_pinfo2(self, parameter_s='', namespaces=None):
558 """Provide extra detailed information about an object.
558 """Provide extra detailed information about an object.
559
559
560 '%pinfo2 object' is just a synonym for object?? or ??object."""
560 '%pinfo2 object' is just a synonym for object?? or ??object."""
561 self.shell._inspect('pinfo', parameter_s, detail_level=1,
561 self.shell._inspect('pinfo', parameter_s, detail_level=1,
562 namespaces=namespaces)
562 namespaces=namespaces)
563
563
564 @testdec.skip_doctest
564 @testdec.skip_doctest
565 def magic_pdef(self, parameter_s='', namespaces=None):
565 def magic_pdef(self, parameter_s='', namespaces=None):
566 """Print the definition header for any callable object.
566 """Print the definition header for any callable object.
567
567
568 If the object is a class, print the constructor information.
568 If the object is a class, print the constructor information.
569
569
570 Examples
570 Examples
571 --------
571 --------
572 ::
572 ::
573
573
574 In [3]: %pdef urllib.urlopen
574 In [3]: %pdef urllib.urlopen
575 urllib.urlopen(url, data=None, proxies=None)
575 urllib.urlopen(url, data=None, proxies=None)
576 """
576 """
577 self._inspect('pdef',parameter_s, namespaces)
577 self._inspect('pdef',parameter_s, namespaces)
578
578
579 def magic_pdoc(self, parameter_s='', namespaces=None):
579 def magic_pdoc(self, parameter_s='', namespaces=None):
580 """Print the docstring for an object.
580 """Print the docstring for an object.
581
581
582 If the given object is a class, it will print both the class and the
582 If the given object is a class, it will print both the class and the
583 constructor docstrings."""
583 constructor docstrings."""
584 self._inspect('pdoc',parameter_s, namespaces)
584 self._inspect('pdoc',parameter_s, namespaces)
585
585
586 def magic_psource(self, parameter_s='', namespaces=None):
586 def magic_psource(self, parameter_s='', namespaces=None):
587 """Print (or run through pager) the source code for an object."""
587 """Print (or run through pager) the source code for an object."""
588 self._inspect('psource',parameter_s, namespaces)
588 self._inspect('psource',parameter_s, namespaces)
589
589
590 def magic_pfile(self, parameter_s=''):
590 def magic_pfile(self, parameter_s=''):
591 """Print (or run through pager) the file where an object is defined.
591 """Print (or run through pager) the file where an object is defined.
592
592
593 The file opens at the line where the object definition begins. IPython
593 The file opens at the line where the object definition begins. IPython
594 will honor the environment variable PAGER if set, and otherwise will
594 will honor the environment variable PAGER if set, and otherwise will
595 do its best to print the file in a convenient form.
595 do its best to print the file in a convenient form.
596
596
597 If the given argument is not an object currently defined, IPython will
597 If the given argument is not an object currently defined, IPython will
598 try to interpret it as a filename (automatically adding a .py extension
598 try to interpret it as a filename (automatically adding a .py extension
599 if needed). You can thus use %pfile as a syntax highlighting code
599 if needed). You can thus use %pfile as a syntax highlighting code
600 viewer."""
600 viewer."""
601
601
602 # first interpret argument as an object name
602 # first interpret argument as an object name
603 out = self._inspect('pfile',parameter_s)
603 out = self._inspect('pfile',parameter_s)
604 # if not, try the input as a filename
604 # if not, try the input as a filename
605 if out == 'not found':
605 if out == 'not found':
606 try:
606 try:
607 filename = get_py_filename(parameter_s)
607 filename = get_py_filename(parameter_s)
608 except IOError,msg:
608 except IOError,msg:
609 print msg
609 print msg
610 return
610 return
611 page.page(self.shell.inspector.format(file(filename).read()))
611 page.page(self.shell.inspector.format(file(filename).read()))
612
612
613 def magic_psearch(self, parameter_s=''):
613 def magic_psearch(self, parameter_s=''):
614 """Search for object in namespaces by wildcard.
614 """Search for object in namespaces by wildcard.
615
615
616 %psearch [options] PATTERN [OBJECT TYPE]
616 %psearch [options] PATTERN [OBJECT TYPE]
617
617
618 Note: ? can be used as a synonym for %psearch, at the beginning or at
618 Note: ? can be used as a synonym for %psearch, at the beginning or at
619 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
619 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
620 rest of the command line must be unchanged (options come first), so
620 rest of the command line must be unchanged (options come first), so
621 for example the following forms are equivalent
621 for example the following forms are equivalent
622
622
623 %psearch -i a* function
623 %psearch -i a* function
624 -i a* function?
624 -i a* function?
625 ?-i a* function
625 ?-i a* function
626
626
627 Arguments:
627 Arguments:
628
628
629 PATTERN
629 PATTERN
630
630
631 where PATTERN is a string containing * as a wildcard similar to its
631 where PATTERN is a string containing * as a wildcard similar to its
632 use in a shell. The pattern is matched in all namespaces on the
632 use in a shell. The pattern is matched in all namespaces on the
633 search path. By default objects starting with a single _ are not
633 search path. By default objects starting with a single _ are not
634 matched, many IPython generated objects have a single
634 matched, many IPython generated objects have a single
635 underscore. The default is case insensitive matching. Matching is
635 underscore. The default is case insensitive matching. Matching is
636 also done on the attributes of objects and not only on the objects
636 also done on the attributes of objects and not only on the objects
637 in a module.
637 in a module.
638
638
639 [OBJECT TYPE]
639 [OBJECT TYPE]
640
640
641 Is the name of a python type from the types module. The name is
641 Is the name of a python type from the types module. The name is
642 given in lowercase without the ending type, ex. StringType is
642 given in lowercase without the ending type, ex. StringType is
643 written string. By adding a type here only objects matching the
643 written string. By adding a type here only objects matching the
644 given type are matched. Using all here makes the pattern match all
644 given type are matched. Using all here makes the pattern match all
645 types (this is the default).
645 types (this is the default).
646
646
647 Options:
647 Options:
648
648
649 -a: makes the pattern match even objects whose names start with a
649 -a: makes the pattern match even objects whose names start with a
650 single underscore. These names are normally ommitted from the
650 single underscore. These names are normally ommitted from the
651 search.
651 search.
652
652
653 -i/-c: make the pattern case insensitive/sensitive. If neither of
653 -i/-c: make the pattern case insensitive/sensitive. If neither of
654 these options is given, the default is read from your ipythonrc
654 these options is given, the default is read from your ipythonrc
655 file. The option name which sets this value is
655 file. The option name which sets this value is
656 'wildcards_case_sensitive'. If this option is not specified in your
656 'wildcards_case_sensitive'. If this option is not specified in your
657 ipythonrc file, IPython's internal default is to do a case sensitive
657 ipythonrc file, IPython's internal default is to do a case sensitive
658 search.
658 search.
659
659
660 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
660 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
661 specifiy can be searched in any of the following namespaces:
661 specifiy can be searched in any of the following namespaces:
662 'builtin', 'user', 'user_global','internal', 'alias', where
662 'builtin', 'user', 'user_global','internal', 'alias', where
663 'builtin' and 'user' are the search defaults. Note that you should
663 'builtin' and 'user' are the search defaults. Note that you should
664 not use quotes when specifying namespaces.
664 not use quotes when specifying namespaces.
665
665
666 'Builtin' contains the python module builtin, 'user' contains all
666 'Builtin' contains the python module builtin, 'user' contains all
667 user data, 'alias' only contain the shell aliases and no python
667 user data, 'alias' only contain the shell aliases and no python
668 objects, 'internal' contains objects used by IPython. The
668 objects, 'internal' contains objects used by IPython. The
669 'user_global' namespace is only used by embedded IPython instances,
669 'user_global' namespace is only used by embedded IPython instances,
670 and it contains module-level globals. You can add namespaces to the
670 and it contains module-level globals. You can add namespaces to the
671 search with -s or exclude them with -e (these options can be given
671 search with -s or exclude them with -e (these options can be given
672 more than once).
672 more than once).
673
673
674 Examples:
674 Examples:
675
675
676 %psearch a* -> objects beginning with an a
676 %psearch a* -> objects beginning with an a
677 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
677 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
678 %psearch a* function -> all functions beginning with an a
678 %psearch a* function -> all functions beginning with an a
679 %psearch re.e* -> objects beginning with an e in module re
679 %psearch re.e* -> objects beginning with an e in module re
680 %psearch r*.e* -> objects that start with e in modules starting in r
680 %psearch r*.e* -> objects that start with e in modules starting in r
681 %psearch r*.* string -> all strings in modules beginning with r
681 %psearch r*.* string -> all strings in modules beginning with r
682
682
683 Case sensitve search:
683 Case sensitve search:
684
684
685 %psearch -c a* list all object beginning with lower case a
685 %psearch -c a* list all object beginning with lower case a
686
686
687 Show objects beginning with a single _:
687 Show objects beginning with a single _:
688
688
689 %psearch -a _* list objects beginning with a single underscore"""
689 %psearch -a _* list objects beginning with a single underscore"""
690 try:
690 try:
691 parameter_s = parameter_s.encode('ascii')
691 parameter_s = parameter_s.encode('ascii')
692 except UnicodeEncodeError:
692 except UnicodeEncodeError:
693 print 'Python identifiers can only contain ascii characters.'
693 print 'Python identifiers can only contain ascii characters.'
694 return
694 return
695
695
696 # default namespaces to be searched
696 # default namespaces to be searched
697 def_search = ['user','builtin']
697 def_search = ['user','builtin']
698
698
699 # Process options/args
699 # Process options/args
700 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
700 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
701 opt = opts.get
701 opt = opts.get
702 shell = self.shell
702 shell = self.shell
703 psearch = shell.inspector.psearch
703 psearch = shell.inspector.psearch
704
704
705 # select case options
705 # select case options
706 if opts.has_key('i'):
706 if opts.has_key('i'):
707 ignore_case = True
707 ignore_case = True
708 elif opts.has_key('c'):
708 elif opts.has_key('c'):
709 ignore_case = False
709 ignore_case = False
710 else:
710 else:
711 ignore_case = not shell.wildcards_case_sensitive
711 ignore_case = not shell.wildcards_case_sensitive
712
712
713 # Build list of namespaces to search from user options
713 # Build list of namespaces to search from user options
714 def_search.extend(opt('s',[]))
714 def_search.extend(opt('s',[]))
715 ns_exclude = ns_exclude=opt('e',[])
715 ns_exclude = ns_exclude=opt('e',[])
716 ns_search = [nm for nm in def_search if nm not in ns_exclude]
716 ns_search = [nm for nm in def_search if nm not in ns_exclude]
717
717
718 # Call the actual search
718 # Call the actual search
719 try:
719 try:
720 psearch(args,shell.ns_table,ns_search,
720 psearch(args,shell.ns_table,ns_search,
721 show_all=opt('a'),ignore_case=ignore_case)
721 show_all=opt('a'),ignore_case=ignore_case)
722 except:
722 except:
723 shell.showtraceback()
723 shell.showtraceback()
724
724
725 @testdec.skip_doctest
725 @testdec.skip_doctest
726 def magic_who_ls(self, parameter_s=''):
726 def magic_who_ls(self, parameter_s=''):
727 """Return a sorted list of all interactive variables.
727 """Return a sorted list of all interactive variables.
728
728
729 If arguments are given, only variables of types matching these
729 If arguments are given, only variables of types matching these
730 arguments are returned.
730 arguments are returned.
731
731
732 Examples
732 Examples
733 --------
733 --------
734
734
735 Define two variables and list them with who_ls::
735 Define two variables and list them with who_ls::
736
736
737 In [1]: alpha = 123
737 In [1]: alpha = 123
738
738
739 In [2]: beta = 'test'
739 In [2]: beta = 'test'
740
740
741 In [3]: %who_ls
741 In [3]: %who_ls
742 Out[3]: ['alpha', 'beta']
742 Out[3]: ['alpha', 'beta']
743
743
744 In [4]: %who_ls int
744 In [4]: %who_ls int
745 Out[4]: ['alpha']
745 Out[4]: ['alpha']
746
746
747 In [5]: %who_ls str
747 In [5]: %who_ls str
748 Out[5]: ['beta']
748 Out[5]: ['beta']
749 """
749 """
750
750
751 user_ns = self.shell.user_ns
751 user_ns = self.shell.user_ns
752 internal_ns = self.shell.internal_ns
752 internal_ns = self.shell.internal_ns
753 user_ns_hidden = self.shell.user_ns_hidden
753 user_ns_hidden = self.shell.user_ns_hidden
754 out = [ i for i in user_ns
754 out = [ i for i in user_ns
755 if not i.startswith('_') \
755 if not i.startswith('_') \
756 and not (i in internal_ns or i in user_ns_hidden) ]
756 and not (i in internal_ns or i in user_ns_hidden) ]
757
757
758 typelist = parameter_s.split()
758 typelist = parameter_s.split()
759 if typelist:
759 if typelist:
760 typeset = set(typelist)
760 typeset = set(typelist)
761 out = [i for i in out if type(user_ns[i]).__name__ in typeset]
761 out = [i for i in out if type(user_ns[i]).__name__ in typeset]
762
762
763 out.sort()
763 out.sort()
764 return out
764 return out
765
765
766 @testdec.skip_doctest
766 @testdec.skip_doctest
767 def magic_who(self, parameter_s=''):
767 def magic_who(self, parameter_s=''):
768 """Print all interactive variables, with some minimal formatting.
768 """Print all interactive variables, with some minimal formatting.
769
769
770 If any arguments are given, only variables whose type matches one of
770 If any arguments are given, only variables whose type matches one of
771 these are printed. For example:
771 these are printed. For example:
772
772
773 %who function str
773 %who function str
774
774
775 will only list functions and strings, excluding all other types of
775 will only list functions and strings, excluding all other types of
776 variables. To find the proper type names, simply use type(var) at a
776 variables. To find the proper type names, simply use type(var) at a
777 command line to see how python prints type names. For example:
777 command line to see how python prints type names. For example:
778
778
779 In [1]: type('hello')\\
779 In [1]: type('hello')\\
780 Out[1]: <type 'str'>
780 Out[1]: <type 'str'>
781
781
782 indicates that the type name for strings is 'str'.
782 indicates that the type name for strings is 'str'.
783
783
784 %who always excludes executed names loaded through your configuration
784 %who always excludes executed names loaded through your configuration
785 file and things which are internal to IPython.
785 file and things which are internal to IPython.
786
786
787 This is deliberate, as typically you may load many modules and the
787 This is deliberate, as typically you may load many modules and the
788 purpose of %who is to show you only what you've manually defined.
788 purpose of %who is to show you only what you've manually defined.
789
789
790 Examples
790 Examples
791 --------
791 --------
792
792
793 Define two variables and list them with who::
793 Define two variables and list them with who::
794
794
795 In [1]: alpha = 123
795 In [1]: alpha = 123
796
796
797 In [2]: beta = 'test'
797 In [2]: beta = 'test'
798
798
799 In [3]: %who
799 In [3]: %who
800 alpha beta
800 alpha beta
801
801
802 In [4]: %who int
802 In [4]: %who int
803 alpha
803 alpha
804
804
805 In [5]: %who str
805 In [5]: %who str
806 beta
806 beta
807 """
807 """
808
808
809 varlist = self.magic_who_ls(parameter_s)
809 varlist = self.magic_who_ls(parameter_s)
810 if not varlist:
810 if not varlist:
811 if parameter_s:
811 if parameter_s:
812 print 'No variables match your requested type.'
812 print 'No variables match your requested type.'
813 else:
813 else:
814 print 'Interactive namespace is empty.'
814 print 'Interactive namespace is empty.'
815 return
815 return
816
816
817 # if we have variables, move on...
817 # if we have variables, move on...
818 count = 0
818 count = 0
819 for i in varlist:
819 for i in varlist:
820 print i+'\t',
820 print i+'\t',
821 count += 1
821 count += 1
822 if count > 8:
822 if count > 8:
823 count = 0
823 count = 0
824 print
824 print
825 print
825 print
826
826
827 @testdec.skip_doctest
827 @testdec.skip_doctest
828 def magic_whos(self, parameter_s=''):
828 def magic_whos(self, parameter_s=''):
829 """Like %who, but gives some extra information about each variable.
829 """Like %who, but gives some extra information about each variable.
830
830
831 The same type filtering of %who can be applied here.
831 The same type filtering of %who can be applied here.
832
832
833 For all variables, the type is printed. Additionally it prints:
833 For all variables, the type is printed. Additionally it prints:
834
834
835 - For {},[],(): their length.
835 - For {},[],(): their length.
836
836
837 - For numpy and Numeric arrays, a summary with shape, number of
837 - For numpy and Numeric arrays, a summary with shape, number of
838 elements, typecode and size in memory.
838 elements, typecode and size in memory.
839
839
840 - Everything else: a string representation, snipping their middle if
840 - Everything else: a string representation, snipping their middle if
841 too long.
841 too long.
842
842
843 Examples
843 Examples
844 --------
844 --------
845
845
846 Define two variables and list them with whos::
846 Define two variables and list them with whos::
847
847
848 In [1]: alpha = 123
848 In [1]: alpha = 123
849
849
850 In [2]: beta = 'test'
850 In [2]: beta = 'test'
851
851
852 In [3]: %whos
852 In [3]: %whos
853 Variable Type Data/Info
853 Variable Type Data/Info
854 --------------------------------
854 --------------------------------
855 alpha int 123
855 alpha int 123
856 beta str test
856 beta str test
857 """
857 """
858
858
859 varnames = self.magic_who_ls(parameter_s)
859 varnames = self.magic_who_ls(parameter_s)
860 if not varnames:
860 if not varnames:
861 if parameter_s:
861 if parameter_s:
862 print 'No variables match your requested type.'
862 print 'No variables match your requested type.'
863 else:
863 else:
864 print 'Interactive namespace is empty.'
864 print 'Interactive namespace is empty.'
865 return
865 return
866
866
867 # if we have variables, move on...
867 # if we have variables, move on...
868
868
869 # for these types, show len() instead of data:
869 # for these types, show len() instead of data:
870 seq_types = [types.DictType,types.ListType,types.TupleType]
870 seq_types = [types.DictType,types.ListType,types.TupleType]
871
871
872 # for numpy/Numeric arrays, display summary info
872 # for numpy/Numeric arrays, display summary info
873 try:
873 try:
874 import numpy
874 import numpy
875 except ImportError:
875 except ImportError:
876 ndarray_type = None
876 ndarray_type = None
877 else:
877 else:
878 ndarray_type = numpy.ndarray.__name__
878 ndarray_type = numpy.ndarray.__name__
879 try:
879 try:
880 import Numeric
880 import Numeric
881 except ImportError:
881 except ImportError:
882 array_type = None
882 array_type = None
883 else:
883 else:
884 array_type = Numeric.ArrayType.__name__
884 array_type = Numeric.ArrayType.__name__
885
885
886 # Find all variable names and types so we can figure out column sizes
886 # Find all variable names and types so we can figure out column sizes
887 def get_vars(i):
887 def get_vars(i):
888 return self.shell.user_ns[i]
888 return self.shell.user_ns[i]
889
889
890 # some types are well known and can be shorter
890 # some types are well known and can be shorter
891 abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
891 abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
892 def type_name(v):
892 def type_name(v):
893 tn = type(v).__name__
893 tn = type(v).__name__
894 return abbrevs.get(tn,tn)
894 return abbrevs.get(tn,tn)
895
895
896 varlist = map(get_vars,varnames)
896 varlist = map(get_vars,varnames)
897
897
898 typelist = []
898 typelist = []
899 for vv in varlist:
899 for vv in varlist:
900 tt = type_name(vv)
900 tt = type_name(vv)
901
901
902 if tt=='instance':
902 if tt=='instance':
903 typelist.append( abbrevs.get(str(vv.__class__),
903 typelist.append( abbrevs.get(str(vv.__class__),
904 str(vv.__class__)))
904 str(vv.__class__)))
905 else:
905 else:
906 typelist.append(tt)
906 typelist.append(tt)
907
907
908 # column labels and # of spaces as separator
908 # column labels and # of spaces as separator
909 varlabel = 'Variable'
909 varlabel = 'Variable'
910 typelabel = 'Type'
910 typelabel = 'Type'
911 datalabel = 'Data/Info'
911 datalabel = 'Data/Info'
912 colsep = 3
912 colsep = 3
913 # variable format strings
913 # variable format strings
914 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
914 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
915 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
915 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
916 aformat = "%s: %s elems, type `%s`, %s bytes"
916 aformat = "%s: %s elems, type `%s`, %s bytes"
917 # find the size of the columns to format the output nicely
917 # find the size of the columns to format the output nicely
918 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
918 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
919 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
919 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
920 # table header
920 # table header
921 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
921 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
922 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
922 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
923 # and the table itself
923 # and the table itself
924 kb = 1024
924 kb = 1024
925 Mb = 1048576 # kb**2
925 Mb = 1048576 # kb**2
926 for vname,var,vtype in zip(varnames,varlist,typelist):
926 for vname,var,vtype in zip(varnames,varlist,typelist):
927 print itpl(vformat),
927 print itpl(vformat),
928 if vtype in seq_types:
928 if vtype in seq_types:
929 print len(var)
929 print len(var)
930 elif vtype in [array_type,ndarray_type]:
930 elif vtype in [array_type,ndarray_type]:
931 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
931 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
932 if vtype==ndarray_type:
932 if vtype==ndarray_type:
933 # numpy
933 # numpy
934 vsize = var.size
934 vsize = var.size
935 vbytes = vsize*var.itemsize
935 vbytes = vsize*var.itemsize
936 vdtype = var.dtype
936 vdtype = var.dtype
937 else:
937 else:
938 # Numeric
938 # Numeric
939 vsize = Numeric.size(var)
939 vsize = Numeric.size(var)
940 vbytes = vsize*var.itemsize()
940 vbytes = vsize*var.itemsize()
941 vdtype = var.typecode()
941 vdtype = var.typecode()
942
942
943 if vbytes < 100000:
943 if vbytes < 100000:
944 print aformat % (vshape,vsize,vdtype,vbytes)
944 print aformat % (vshape,vsize,vdtype,vbytes)
945 else:
945 else:
946 print aformat % (vshape,vsize,vdtype,vbytes),
946 print aformat % (vshape,vsize,vdtype,vbytes),
947 if vbytes < Mb:
947 if vbytes < Mb:
948 print '(%s kb)' % (vbytes/kb,)
948 print '(%s kb)' % (vbytes/kb,)
949 else:
949 else:
950 print '(%s Mb)' % (vbytes/Mb,)
950 print '(%s Mb)' % (vbytes/Mb,)
951 else:
951 else:
952 try:
952 try:
953 vstr = str(var)
953 vstr = str(var)
954 except UnicodeEncodeError:
954 except UnicodeEncodeError:
955 vstr = unicode(var).encode(sys.getdefaultencoding(),
955 vstr = unicode(var).encode(sys.getdefaultencoding(),
956 'backslashreplace')
956 'backslashreplace')
957 vstr = vstr.replace('\n','\\n')
957 vstr = vstr.replace('\n','\\n')
958 if len(vstr) < 50:
958 if len(vstr) < 50:
959 print vstr
959 print vstr
960 else:
960 else:
961 printpl(vfmt_short)
961 printpl(vfmt_short)
962
962
963 def magic_reset(self, parameter_s=''):
963 def magic_reset(self, parameter_s=''):
964 """Resets the namespace by removing all names defined by the user.
964 """Resets the namespace by removing all names defined by the user.
965
965
966 Input/Output history are left around in case you need them.
966 Input/Output history are left around in case you need them.
967
967
968 Parameters
968 Parameters
969 ----------
969 ----------
970 -y : force reset without asking for confirmation.
970 -y : force reset without asking for confirmation.
971
971
972 Examples
972 Examples
973 --------
973 --------
974 In [6]: a = 1
974 In [6]: a = 1
975
975
976 In [7]: a
976 In [7]: a
977 Out[7]: 1
977 Out[7]: 1
978
978
979 In [8]: 'a' in _ip.user_ns
979 In [8]: 'a' in _ip.user_ns
980 Out[8]: True
980 Out[8]: True
981
981
982 In [9]: %reset -f
982 In [9]: %reset -f
983
983
984 In [10]: 'a' in _ip.user_ns
984 In [10]: 'a' in _ip.user_ns
985 Out[10]: False
985 Out[10]: False
986 """
986 """
987
987
988 if parameter_s == '-f':
988 if parameter_s == '-f':
989 ans = True
989 ans = True
990 else:
990 else:
991 ans = self.shell.ask_yes_no(
991 ans = self.shell.ask_yes_no(
992 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
992 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
993 if not ans:
993 if not ans:
994 print 'Nothing done.'
994 print 'Nothing done.'
995 return
995 return
996 user_ns = self.shell.user_ns
996 user_ns = self.shell.user_ns
997 for i in self.magic_who_ls():
997 for i in self.magic_who_ls():
998 del(user_ns[i])
998 del(user_ns[i])
999
999
1000 # Also flush the private list of module references kept for script
1000 # Also flush the private list of module references kept for script
1001 # execution protection
1001 # execution protection
1002 self.shell.clear_main_mod_cache()
1002 self.shell.clear_main_mod_cache()
1003
1003
1004 def magic_reset_selective(self, parameter_s=''):
1004 def magic_reset_selective(self, parameter_s=''):
1005 """Resets the namespace by removing names defined by the user.
1005 """Resets the namespace by removing names defined by the user.
1006
1006
1007 Input/Output history are left around in case you need them.
1007 Input/Output history are left around in case you need them.
1008
1008
1009 %reset_selective [-f] regex
1009 %reset_selective [-f] regex
1010
1010
1011 No action is taken if regex is not included
1011 No action is taken if regex is not included
1012
1012
1013 Options
1013 Options
1014 -f : force reset without asking for confirmation.
1014 -f : force reset without asking for confirmation.
1015
1015
1016 Examples
1016 Examples
1017 --------
1017 --------
1018
1018
1019 We first fully reset the namespace so your output looks identical to
1019 We first fully reset the namespace so your output looks identical to
1020 this example for pedagogical reasons; in practice you do not need a
1020 this example for pedagogical reasons; in practice you do not need a
1021 full reset.
1021 full reset.
1022
1022
1023 In [1]: %reset -f
1023 In [1]: %reset -f
1024
1024
1025 Now, with a clean namespace we can make a few variables and use
1025 Now, with a clean namespace we can make a few variables and use
1026 %reset_selective to only delete names that match our regexp:
1026 %reset_selective to only delete names that match our regexp:
1027
1027
1028 In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
1028 In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
1029
1029
1030 In [3]: who_ls
1030 In [3]: who_ls
1031 Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
1031 Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
1032
1032
1033 In [4]: %reset_selective -f b[2-3]m
1033 In [4]: %reset_selective -f b[2-3]m
1034
1034
1035 In [5]: who_ls
1035 In [5]: who_ls
1036 Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
1036 Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
1037
1037
1038 In [6]: %reset_selective -f d
1038 In [6]: %reset_selective -f d
1039
1039
1040 In [7]: who_ls
1040 In [7]: who_ls
1041 Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
1041 Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
1042
1042
1043 In [8]: %reset_selective -f c
1043 In [8]: %reset_selective -f c
1044
1044
1045 In [9]: who_ls
1045 In [9]: who_ls
1046 Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
1046 Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
1047
1047
1048 In [10]: %reset_selective -f b
1048 In [10]: %reset_selective -f b
1049
1049
1050 In [11]: who_ls
1050 In [11]: who_ls
1051 Out[11]: ['a']
1051 Out[11]: ['a']
1052 """
1052 """
1053
1053
1054 opts, regex = self.parse_options(parameter_s,'f')
1054 opts, regex = self.parse_options(parameter_s,'f')
1055
1055
1056 if opts.has_key('f'):
1056 if opts.has_key('f'):
1057 ans = True
1057 ans = True
1058 else:
1058 else:
1059 ans = self.shell.ask_yes_no(
1059 ans = self.shell.ask_yes_no(
1060 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
1060 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
1061 if not ans:
1061 if not ans:
1062 print 'Nothing done.'
1062 print 'Nothing done.'
1063 return
1063 return
1064 user_ns = self.shell.user_ns
1064 user_ns = self.shell.user_ns
1065 if not regex:
1065 if not regex:
1066 print 'No regex pattern specified. Nothing done.'
1066 print 'No regex pattern specified. Nothing done.'
1067 return
1067 return
1068 else:
1068 else:
1069 try:
1069 try:
1070 m = re.compile(regex)
1070 m = re.compile(regex)
1071 except TypeError:
1071 except TypeError:
1072 raise TypeError('regex must be a string or compiled pattern')
1072 raise TypeError('regex must be a string or compiled pattern')
1073 for i in self.magic_who_ls():
1073 for i in self.magic_who_ls():
1074 if m.search(i):
1074 if m.search(i):
1075 del(user_ns[i])
1075 del(user_ns[i])
1076
1076
1077 def magic_logstart(self,parameter_s=''):
1077 def magic_logstart(self,parameter_s=''):
1078 """Start logging anywhere in a session.
1078 """Start logging anywhere in a session.
1079
1079
1080 %logstart [-o|-r|-t] [log_name [log_mode]]
1080 %logstart [-o|-r|-t] [log_name [log_mode]]
1081
1081
1082 If no name is given, it defaults to a file named 'ipython_log.py' in your
1082 If no name is given, it defaults to a file named 'ipython_log.py' in your
1083 current directory, in 'rotate' mode (see below).
1083 current directory, in 'rotate' mode (see below).
1084
1084
1085 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1085 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1086 history up to that point and then continues logging.
1086 history up to that point and then continues logging.
1087
1087
1088 %logstart takes a second optional parameter: logging mode. This can be one
1088 %logstart takes a second optional parameter: logging mode. This can be one
1089 of (note that the modes are given unquoted):\\
1089 of (note that the modes are given unquoted):\\
1090 append: well, that says it.\\
1090 append: well, that says it.\\
1091 backup: rename (if exists) to name~ and start name.\\
1091 backup: rename (if exists) to name~ and start name.\\
1092 global: single logfile in your home dir, appended to.\\
1092 global: single logfile in your home dir, appended to.\\
1093 over : overwrite existing log.\\
1093 over : overwrite existing log.\\
1094 rotate: create rotating logs name.1~, name.2~, etc.
1094 rotate: create rotating logs name.1~, name.2~, etc.
1095
1095
1096 Options:
1096 Options:
1097
1097
1098 -o: log also IPython's output. In this mode, all commands which
1098 -o: log also IPython's output. In this mode, all commands which
1099 generate an Out[NN] prompt are recorded to the logfile, right after
1099 generate an Out[NN] prompt are recorded to the logfile, right after
1100 their corresponding input line. The output lines are always
1100 their corresponding input line. The output lines are always
1101 prepended with a '#[Out]# ' marker, so that the log remains valid
1101 prepended with a '#[Out]# ' marker, so that the log remains valid
1102 Python code.
1102 Python code.
1103
1103
1104 Since this marker is always the same, filtering only the output from
1104 Since this marker is always the same, filtering only the output from
1105 a log is very easy, using for example a simple awk call:
1105 a log is very easy, using for example a simple awk call:
1106
1106
1107 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1107 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1108
1108
1109 -r: log 'raw' input. Normally, IPython's logs contain the processed
1109 -r: log 'raw' input. Normally, IPython's logs contain the processed
1110 input, so that user lines are logged in their final form, converted
1110 input, so that user lines are logged in their final form, converted
1111 into valid Python. For example, %Exit is logged as
1111 into valid Python. For example, %Exit is logged as
1112 '_ip.magic("Exit"). If the -r flag is given, all input is logged
1112 '_ip.magic("Exit"). If the -r flag is given, all input is logged
1113 exactly as typed, with no transformations applied.
1113 exactly as typed, with no transformations applied.
1114
1114
1115 -t: put timestamps before each input line logged (these are put in
1115 -t: put timestamps before each input line logged (these are put in
1116 comments)."""
1116 comments)."""
1117
1117
1118 opts,par = self.parse_options(parameter_s,'ort')
1118 opts,par = self.parse_options(parameter_s,'ort')
1119 log_output = 'o' in opts
1119 log_output = 'o' in opts
1120 log_raw_input = 'r' in opts
1120 log_raw_input = 'r' in opts
1121 timestamp = 't' in opts
1121 timestamp = 't' in opts
1122
1122
1123 logger = self.shell.logger
1123 logger = self.shell.logger
1124
1124
1125 # if no args are given, the defaults set in the logger constructor by
1125 # if no args are given, the defaults set in the logger constructor by
1126 # ipytohn remain valid
1126 # ipytohn remain valid
1127 if par:
1127 if par:
1128 try:
1128 try:
1129 logfname,logmode = par.split()
1129 logfname,logmode = par.split()
1130 except:
1130 except:
1131 logfname = par
1131 logfname = par
1132 logmode = 'backup'
1132 logmode = 'backup'
1133 else:
1133 else:
1134 logfname = logger.logfname
1134 logfname = logger.logfname
1135 logmode = logger.logmode
1135 logmode = logger.logmode
1136 # put logfname into rc struct as if it had been called on the command
1136 # put logfname into rc struct as if it had been called on the command
1137 # line, so it ends up saved in the log header Save it in case we need
1137 # line, so it ends up saved in the log header Save it in case we need
1138 # to restore it...
1138 # to restore it...
1139 old_logfile = self.shell.logfile
1139 old_logfile = self.shell.logfile
1140 if logfname:
1140 if logfname:
1141 logfname = os.path.expanduser(logfname)
1141 logfname = os.path.expanduser(logfname)
1142 self.shell.logfile = logfname
1142 self.shell.logfile = logfname
1143
1143
1144 loghead = '# IPython log file\n\n'
1144 loghead = '# IPython log file\n\n'
1145 try:
1145 try:
1146 started = logger.logstart(logfname,loghead,logmode,
1146 started = logger.logstart(logfname,loghead,logmode,
1147 log_output,timestamp,log_raw_input)
1147 log_output,timestamp,log_raw_input)
1148 except:
1148 except:
1149 self.shell.logfile = old_logfile
1149 self.shell.logfile = old_logfile
1150 warn("Couldn't start log: %s" % sys.exc_info()[1])
1150 warn("Couldn't start log: %s" % sys.exc_info()[1])
1151 else:
1151 else:
1152 # log input history up to this point, optionally interleaving
1152 # log input history up to this point, optionally interleaving
1153 # output if requested
1153 # output if requested
1154
1154
1155 if timestamp:
1155 if timestamp:
1156 # disable timestamping for the previous history, since we've
1156 # disable timestamping for the previous history, since we've
1157 # lost those already (no time machine here).
1157 # lost those already (no time machine here).
1158 logger.timestamp = False
1158 logger.timestamp = False
1159
1159
1160 if log_raw_input:
1160 if log_raw_input:
1161 input_hist = self.shell.history_manager.input_hist_raw
1161 input_hist = self.shell.history_manager.input_hist_raw
1162 else:
1162 else:
1163 input_hist = self.shell.history_manager.input_hist_parsed
1163 input_hist = self.shell.history_manager.input_hist_parsed
1164
1164
1165 if log_output:
1165 if log_output:
1166 log_write = logger.log_write
1166 log_write = logger.log_write
1167 output_hist = self.shell.history_manager.output_hist
1167 output_hist = self.shell.history_manager.output_hist
1168 for n in range(1,len(input_hist)-1):
1168 for n in range(1,len(input_hist)-1):
1169 log_write(input_hist[n].rstrip())
1169 log_write(input_hist[n].rstrip())
1170 if n in output_hist:
1170 if n in output_hist:
1171 log_write(repr(output_hist[n]),'output')
1171 log_write(repr(output_hist[n]),'output')
1172 else:
1172 else:
1173 logger.log_write(''.join(input_hist[1:]))
1173 logger.log_write(''.join(input_hist[1:]))
1174 if timestamp:
1174 if timestamp:
1175 # re-enable timestamping
1175 # re-enable timestamping
1176 logger.timestamp = True
1176 logger.timestamp = True
1177
1177
1178 print ('Activating auto-logging. '
1178 print ('Activating auto-logging. '
1179 'Current session state plus future input saved.')
1179 'Current session state plus future input saved.')
1180 logger.logstate()
1180 logger.logstate()
1181
1181
1182 def magic_logstop(self,parameter_s=''):
1182 def magic_logstop(self,parameter_s=''):
1183 """Fully stop logging and close log file.
1183 """Fully stop logging and close log file.
1184
1184
1185 In order to start logging again, a new %logstart call needs to be made,
1185 In order to start logging again, a new %logstart call needs to be made,
1186 possibly (though not necessarily) with a new filename, mode and other
1186 possibly (though not necessarily) with a new filename, mode and other
1187 options."""
1187 options."""
1188 self.logger.logstop()
1188 self.logger.logstop()
1189
1189
1190 def magic_logoff(self,parameter_s=''):
1190 def magic_logoff(self,parameter_s=''):
1191 """Temporarily stop logging.
1191 """Temporarily stop logging.
1192
1192
1193 You must have previously started logging."""
1193 You must have previously started logging."""
1194 self.shell.logger.switch_log(0)
1194 self.shell.logger.switch_log(0)
1195
1195
1196 def magic_logon(self,parameter_s=''):
1196 def magic_logon(self,parameter_s=''):
1197 """Restart logging.
1197 """Restart logging.
1198
1198
1199 This function is for restarting logging which you've temporarily
1199 This function is for restarting logging which you've temporarily
1200 stopped with %logoff. For starting logging for the first time, you
1200 stopped with %logoff. For starting logging for the first time, you
1201 must use the %logstart function, which allows you to specify an
1201 must use the %logstart function, which allows you to specify an
1202 optional log filename."""
1202 optional log filename."""
1203
1203
1204 self.shell.logger.switch_log(1)
1204 self.shell.logger.switch_log(1)
1205
1205
1206 def magic_logstate(self,parameter_s=''):
1206 def magic_logstate(self,parameter_s=''):
1207 """Print the status of the logging system."""
1207 """Print the status of the logging system."""
1208
1208
1209 self.shell.logger.logstate()
1209 self.shell.logger.logstate()
1210
1210
1211 def magic_pdb(self, parameter_s=''):
1211 def magic_pdb(self, parameter_s=''):
1212 """Control the automatic calling of the pdb interactive debugger.
1212 """Control the automatic calling of the pdb interactive debugger.
1213
1213
1214 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1214 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1215 argument it works as a toggle.
1215 argument it works as a toggle.
1216
1216
1217 When an exception is triggered, IPython can optionally call the
1217 When an exception is triggered, IPython can optionally call the
1218 interactive pdb debugger after the traceback printout. %pdb toggles
1218 interactive pdb debugger after the traceback printout. %pdb toggles
1219 this feature on and off.
1219 this feature on and off.
1220
1220
1221 The initial state of this feature is set in your ipythonrc
1221 The initial state of this feature is set in your ipythonrc
1222 configuration file (the variable is called 'pdb').
1222 configuration file (the variable is called 'pdb').
1223
1223
1224 If you want to just activate the debugger AFTER an exception has fired,
1224 If you want to just activate the debugger AFTER an exception has fired,
1225 without having to type '%pdb on' and rerunning your code, you can use
1225 without having to type '%pdb on' and rerunning your code, you can use
1226 the %debug magic."""
1226 the %debug magic."""
1227
1227
1228 par = parameter_s.strip().lower()
1228 par = parameter_s.strip().lower()
1229
1229
1230 if par:
1230 if par:
1231 try:
1231 try:
1232 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1232 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1233 except KeyError:
1233 except KeyError:
1234 print ('Incorrect argument. Use on/1, off/0, '
1234 print ('Incorrect argument. Use on/1, off/0, '
1235 'or nothing for a toggle.')
1235 'or nothing for a toggle.')
1236 return
1236 return
1237 else:
1237 else:
1238 # toggle
1238 # toggle
1239 new_pdb = not self.shell.call_pdb
1239 new_pdb = not self.shell.call_pdb
1240
1240
1241 # set on the shell
1241 # set on the shell
1242 self.shell.call_pdb = new_pdb
1242 self.shell.call_pdb = new_pdb
1243 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1243 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1244
1244
1245 def magic_debug(self, parameter_s=''):
1245 def magic_debug(self, parameter_s=''):
1246 """Activate the interactive debugger in post-mortem mode.
1246 """Activate the interactive debugger in post-mortem mode.
1247
1247
1248 If an exception has just occurred, this lets you inspect its stack
1248 If an exception has just occurred, this lets you inspect its stack
1249 frames interactively. Note that this will always work only on the last
1249 frames interactively. Note that this will always work only on the last
1250 traceback that occurred, so you must call this quickly after an
1250 traceback that occurred, so you must call this quickly after an
1251 exception that you wish to inspect has fired, because if another one
1251 exception that you wish to inspect has fired, because if another one
1252 occurs, it clobbers the previous one.
1252 occurs, it clobbers the previous one.
1253
1253
1254 If you want IPython to automatically do this on every exception, see
1254 If you want IPython to automatically do this on every exception, see
1255 the %pdb magic for more details.
1255 the %pdb magic for more details.
1256 """
1256 """
1257 self.shell.debugger(force=True)
1257 self.shell.debugger(force=True)
1258
1258
1259 @testdec.skip_doctest
1259 @testdec.skip_doctest
1260 def magic_prun(self, parameter_s ='',user_mode=1,
1260 def magic_prun(self, parameter_s ='',user_mode=1,
1261 opts=None,arg_lst=None,prog_ns=None):
1261 opts=None,arg_lst=None,prog_ns=None):
1262
1262
1263 """Run a statement through the python code profiler.
1263 """Run a statement through the python code profiler.
1264
1264
1265 Usage:
1265 Usage:
1266 %prun [options] statement
1266 %prun [options] statement
1267
1267
1268 The given statement (which doesn't require quote marks) is run via the
1268 The given statement (which doesn't require quote marks) is run via the
1269 python profiler in a manner similar to the profile.run() function.
1269 python profiler in a manner similar to the profile.run() function.
1270 Namespaces are internally managed to work correctly; profile.run
1270 Namespaces are internally managed to work correctly; profile.run
1271 cannot be used in IPython because it makes certain assumptions about
1271 cannot be used in IPython because it makes certain assumptions about
1272 namespaces which do not hold under IPython.
1272 namespaces which do not hold under IPython.
1273
1273
1274 Options:
1274 Options:
1275
1275
1276 -l <limit>: you can place restrictions on what or how much of the
1276 -l <limit>: you can place restrictions on what or how much of the
1277 profile gets printed. The limit value can be:
1277 profile gets printed. The limit value can be:
1278
1278
1279 * A string: only information for function names containing this string
1279 * A string: only information for function names containing this string
1280 is printed.
1280 is printed.
1281
1281
1282 * An integer: only these many lines are printed.
1282 * An integer: only these many lines are printed.
1283
1283
1284 * A float (between 0 and 1): this fraction of the report is printed
1284 * A float (between 0 and 1): this fraction of the report is printed
1285 (for example, use a limit of 0.4 to see the topmost 40% only).
1285 (for example, use a limit of 0.4 to see the topmost 40% only).
1286
1286
1287 You can combine several limits with repeated use of the option. For
1287 You can combine several limits with repeated use of the option. For
1288 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1288 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1289 information about class constructors.
1289 information about class constructors.
1290
1290
1291 -r: return the pstats.Stats object generated by the profiling. This
1291 -r: return the pstats.Stats object generated by the profiling. This
1292 object has all the information about the profile in it, and you can
1292 object has all the information about the profile in it, and you can
1293 later use it for further analysis or in other functions.
1293 later use it for further analysis or in other functions.
1294
1294
1295 -s <key>: sort profile by given key. You can provide more than one key
1295 -s <key>: sort profile by given key. You can provide more than one key
1296 by using the option several times: '-s key1 -s key2 -s key3...'. The
1296 by using the option several times: '-s key1 -s key2 -s key3...'. The
1297 default sorting key is 'time'.
1297 default sorting key is 'time'.
1298
1298
1299 The following is copied verbatim from the profile documentation
1299 The following is copied verbatim from the profile documentation
1300 referenced below:
1300 referenced below:
1301
1301
1302 When more than one key is provided, additional keys are used as
1302 When more than one key is provided, additional keys are used as
1303 secondary criteria when the there is equality in all keys selected
1303 secondary criteria when the there is equality in all keys selected
1304 before them.
1304 before them.
1305
1305
1306 Abbreviations can be used for any key names, as long as the
1306 Abbreviations can be used for any key names, as long as the
1307 abbreviation is unambiguous. The following are the keys currently
1307 abbreviation is unambiguous. The following are the keys currently
1308 defined:
1308 defined:
1309
1309
1310 Valid Arg Meaning
1310 Valid Arg Meaning
1311 "calls" call count
1311 "calls" call count
1312 "cumulative" cumulative time
1312 "cumulative" cumulative time
1313 "file" file name
1313 "file" file name
1314 "module" file name
1314 "module" file name
1315 "pcalls" primitive call count
1315 "pcalls" primitive call count
1316 "line" line number
1316 "line" line number
1317 "name" function name
1317 "name" function name
1318 "nfl" name/file/line
1318 "nfl" name/file/line
1319 "stdname" standard name
1319 "stdname" standard name
1320 "time" internal time
1320 "time" internal time
1321
1321
1322 Note that all sorts on statistics are in descending order (placing
1322 Note that all sorts on statistics are in descending order (placing
1323 most time consuming items first), where as name, file, and line number
1323 most time consuming items first), where as name, file, and line number
1324 searches are in ascending order (i.e., alphabetical). The subtle
1324 searches are in ascending order (i.e., alphabetical). The subtle
1325 distinction between "nfl" and "stdname" is that the standard name is a
1325 distinction between "nfl" and "stdname" is that the standard name is a
1326 sort of the name as printed, which means that the embedded line
1326 sort of the name as printed, which means that the embedded line
1327 numbers get compared in an odd way. For example, lines 3, 20, and 40
1327 numbers get compared in an odd way. For example, lines 3, 20, and 40
1328 would (if the file names were the same) appear in the string order
1328 would (if the file names were the same) appear in the string order
1329 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1329 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1330 line numbers. In fact, sort_stats("nfl") is the same as
1330 line numbers. In fact, sort_stats("nfl") is the same as
1331 sort_stats("name", "file", "line").
1331 sort_stats("name", "file", "line").
1332
1332
1333 -T <filename>: save profile results as shown on screen to a text
1333 -T <filename>: save profile results as shown on screen to a text
1334 file. The profile is still shown on screen.
1334 file. The profile is still shown on screen.
1335
1335
1336 -D <filename>: save (via dump_stats) profile statistics to given
1336 -D <filename>: save (via dump_stats) profile statistics to given
1337 filename. This data is in a format understod by the pstats module, and
1337 filename. This data is in a format understod by the pstats module, and
1338 is generated by a call to the dump_stats() method of profile
1338 is generated by a call to the dump_stats() method of profile
1339 objects. The profile is still shown on screen.
1339 objects. The profile is still shown on screen.
1340
1340
1341 If you want to run complete programs under the profiler's control, use
1341 If you want to run complete programs under the profiler's control, use
1342 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1342 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1343 contains profiler specific options as described here.
1343 contains profiler specific options as described here.
1344
1344
1345 You can read the complete documentation for the profile module with::
1345 You can read the complete documentation for the profile module with::
1346
1346
1347 In [1]: import profile; profile.help()
1347 In [1]: import profile; profile.help()
1348 """
1348 """
1349
1349
1350 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1350 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1351 # protect user quote marks
1351 # protect user quote marks
1352 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1352 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1353
1353
1354 if user_mode: # regular user call
1354 if user_mode: # regular user call
1355 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1355 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1356 list_all=1)
1356 list_all=1)
1357 namespace = self.shell.user_ns
1357 namespace = self.shell.user_ns
1358 else: # called to run a program by %run -p
1358 else: # called to run a program by %run -p
1359 try:
1359 try:
1360 filename = get_py_filename(arg_lst[0])
1360 filename = get_py_filename(arg_lst[0])
1361 except IOError,msg:
1361 except IOError,msg:
1362 error(msg)
1362 error(msg)
1363 return
1363 return
1364
1364
1365 arg_str = 'execfile(filename,prog_ns)'
1365 arg_str = 'execfile(filename,prog_ns)'
1366 namespace = locals()
1366 namespace = locals()
1367
1367
1368 opts.merge(opts_def)
1368 opts.merge(opts_def)
1369
1369
1370 prof = profile.Profile()
1370 prof = profile.Profile()
1371 try:
1371 try:
1372 prof = prof.runctx(arg_str,namespace,namespace)
1372 prof = prof.runctx(arg_str,namespace,namespace)
1373 sys_exit = ''
1373 sys_exit = ''
1374 except SystemExit:
1374 except SystemExit:
1375 sys_exit = """*** SystemExit exception caught in code being profiled."""
1375 sys_exit = """*** SystemExit exception caught in code being profiled."""
1376
1376
1377 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1377 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1378
1378
1379 lims = opts.l
1379 lims = opts.l
1380 if lims:
1380 if lims:
1381 lims = [] # rebuild lims with ints/floats/strings
1381 lims = [] # rebuild lims with ints/floats/strings
1382 for lim in opts.l:
1382 for lim in opts.l:
1383 try:
1383 try:
1384 lims.append(int(lim))
1384 lims.append(int(lim))
1385 except ValueError:
1385 except ValueError:
1386 try:
1386 try:
1387 lims.append(float(lim))
1387 lims.append(float(lim))
1388 except ValueError:
1388 except ValueError:
1389 lims.append(lim)
1389 lims.append(lim)
1390
1390
1391 # Trap output.
1391 # Trap output.
1392 stdout_trap = StringIO()
1392 stdout_trap = StringIO()
1393
1393
1394 if hasattr(stats,'stream'):
1394 if hasattr(stats,'stream'):
1395 # In newer versions of python, the stats object has a 'stream'
1395 # In newer versions of python, the stats object has a 'stream'
1396 # attribute to write into.
1396 # attribute to write into.
1397 stats.stream = stdout_trap
1397 stats.stream = stdout_trap
1398 stats.print_stats(*lims)
1398 stats.print_stats(*lims)
1399 else:
1399 else:
1400 # For older versions, we manually redirect stdout during printing
1400 # For older versions, we manually redirect stdout during printing
1401 sys_stdout = sys.stdout
1401 sys_stdout = sys.stdout
1402 try:
1402 try:
1403 sys.stdout = stdout_trap
1403 sys.stdout = stdout_trap
1404 stats.print_stats(*lims)
1404 stats.print_stats(*lims)
1405 finally:
1405 finally:
1406 sys.stdout = sys_stdout
1406 sys.stdout = sys_stdout
1407
1407
1408 output = stdout_trap.getvalue()
1408 output = stdout_trap.getvalue()
1409 output = output.rstrip()
1409 output = output.rstrip()
1410
1410
1411 page.page(output)
1411 page.page(output)
1412 print sys_exit,
1412 print sys_exit,
1413
1413
1414 dump_file = opts.D[0]
1414 dump_file = opts.D[0]
1415 text_file = opts.T[0]
1415 text_file = opts.T[0]
1416 if dump_file:
1416 if dump_file:
1417 prof.dump_stats(dump_file)
1417 prof.dump_stats(dump_file)
1418 print '\n*** Profile stats marshalled to file',\
1418 print '\n*** Profile stats marshalled to file',\
1419 `dump_file`+'.',sys_exit
1419 `dump_file`+'.',sys_exit
1420 if text_file:
1420 if text_file:
1421 pfile = file(text_file,'w')
1421 pfile = file(text_file,'w')
1422 pfile.write(output)
1422 pfile.write(output)
1423 pfile.close()
1423 pfile.close()
1424 print '\n*** Profile printout saved to text file',\
1424 print '\n*** Profile printout saved to text file',\
1425 `text_file`+'.',sys_exit
1425 `text_file`+'.',sys_exit
1426
1426
1427 if opts.has_key('r'):
1427 if opts.has_key('r'):
1428 return stats
1428 return stats
1429 else:
1429 else:
1430 return None
1430 return None
1431
1431
1432 @testdec.skip_doctest
1432 @testdec.skip_doctest
1433 def magic_run(self, parameter_s ='',runner=None,
1433 def magic_run(self, parameter_s ='',runner=None,
1434 file_finder=get_py_filename):
1434 file_finder=get_py_filename):
1435 """Run the named file inside IPython as a program.
1435 """Run the named file inside IPython as a program.
1436
1436
1437 Usage:\\
1437 Usage:\\
1438 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1438 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1439
1439
1440 Parameters after the filename are passed as command-line arguments to
1440 Parameters after the filename are passed as command-line arguments to
1441 the program (put in sys.argv). Then, control returns to IPython's
1441 the program (put in sys.argv). Then, control returns to IPython's
1442 prompt.
1442 prompt.
1443
1443
1444 This is similar to running at a system prompt:\\
1444 This is similar to running at a system prompt:\\
1445 $ python file args\\
1445 $ python file args\\
1446 but with the advantage of giving you IPython's tracebacks, and of
1446 but with the advantage of giving you IPython's tracebacks, and of
1447 loading all variables into your interactive namespace for further use
1447 loading all variables into your interactive namespace for further use
1448 (unless -p is used, see below).
1448 (unless -p is used, see below).
1449
1449
1450 The file is executed in a namespace initially consisting only of
1450 The file is executed in a namespace initially consisting only of
1451 __name__=='__main__' and sys.argv constructed as indicated. It thus
1451 __name__=='__main__' and sys.argv constructed as indicated. It thus
1452 sees its environment as if it were being run as a stand-alone program
1452 sees its environment as if it were being run as a stand-alone program
1453 (except for sharing global objects such as previously imported
1453 (except for sharing global objects such as previously imported
1454 modules). But after execution, the IPython interactive namespace gets
1454 modules). But after execution, the IPython interactive namespace gets
1455 updated with all variables defined in the program (except for __name__
1455 updated with all variables defined in the program (except for __name__
1456 and sys.argv). This allows for very convenient loading of code for
1456 and sys.argv). This allows for very convenient loading of code for
1457 interactive work, while giving each program a 'clean sheet' to run in.
1457 interactive work, while giving each program a 'clean sheet' to run in.
1458
1458
1459 Options:
1459 Options:
1460
1460
1461 -n: __name__ is NOT set to '__main__', but to the running file's name
1461 -n: __name__ is NOT set to '__main__', but to the running file's name
1462 without extension (as python does under import). This allows running
1462 without extension (as python does under import). This allows running
1463 scripts and reloading the definitions in them without calling code
1463 scripts and reloading the definitions in them without calling code
1464 protected by an ' if __name__ == "__main__" ' clause.
1464 protected by an ' if __name__ == "__main__" ' clause.
1465
1465
1466 -i: run the file in IPython's namespace instead of an empty one. This
1466 -i: run the file in IPython's namespace instead of an empty one. This
1467 is useful if you are experimenting with code written in a text editor
1467 is useful if you are experimenting with code written in a text editor
1468 which depends on variables defined interactively.
1468 which depends on variables defined interactively.
1469
1469
1470 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1470 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1471 being run. This is particularly useful if IPython is being used to
1471 being run. This is particularly useful if IPython is being used to
1472 run unittests, which always exit with a sys.exit() call. In such
1472 run unittests, which always exit with a sys.exit() call. In such
1473 cases you are interested in the output of the test results, not in
1473 cases you are interested in the output of the test results, not in
1474 seeing a traceback of the unittest module.
1474 seeing a traceback of the unittest module.
1475
1475
1476 -t: print timing information at the end of the run. IPython will give
1476 -t: print timing information at the end of the run. IPython will give
1477 you an estimated CPU time consumption for your script, which under
1477 you an estimated CPU time consumption for your script, which under
1478 Unix uses the resource module to avoid the wraparound problems of
1478 Unix uses the resource module to avoid the wraparound problems of
1479 time.clock(). Under Unix, an estimate of time spent on system tasks
1479 time.clock(). Under Unix, an estimate of time spent on system tasks
1480 is also given (for Windows platforms this is reported as 0.0).
1480 is also given (for Windows platforms this is reported as 0.0).
1481
1481
1482 If -t is given, an additional -N<N> option can be given, where <N>
1482 If -t is given, an additional -N<N> option can be given, where <N>
1483 must be an integer indicating how many times you want the script to
1483 must be an integer indicating how many times you want the script to
1484 run. The final timing report will include total and per run results.
1484 run. The final timing report will include total and per run results.
1485
1485
1486 For example (testing the script uniq_stable.py):
1486 For example (testing the script uniq_stable.py):
1487
1487
1488 In [1]: run -t uniq_stable
1488 In [1]: run -t uniq_stable
1489
1489
1490 IPython CPU timings (estimated):\\
1490 IPython CPU timings (estimated):\\
1491 User : 0.19597 s.\\
1491 User : 0.19597 s.\\
1492 System: 0.0 s.\\
1492 System: 0.0 s.\\
1493
1493
1494 In [2]: run -t -N5 uniq_stable
1494 In [2]: run -t -N5 uniq_stable
1495
1495
1496 IPython CPU timings (estimated):\\
1496 IPython CPU timings (estimated):\\
1497 Total runs performed: 5\\
1497 Total runs performed: 5\\
1498 Times : Total Per run\\
1498 Times : Total Per run\\
1499 User : 0.910862 s, 0.1821724 s.\\
1499 User : 0.910862 s, 0.1821724 s.\\
1500 System: 0.0 s, 0.0 s.
1500 System: 0.0 s, 0.0 s.
1501
1501
1502 -d: run your program under the control of pdb, the Python debugger.
1502 -d: run your program under the control of pdb, the Python debugger.
1503 This allows you to execute your program step by step, watch variables,
1503 This allows you to execute your program step by step, watch variables,
1504 etc. Internally, what IPython does is similar to calling:
1504 etc. Internally, what IPython does is similar to calling:
1505
1505
1506 pdb.run('execfile("YOURFILENAME")')
1506 pdb.run('execfile("YOURFILENAME")')
1507
1507
1508 with a breakpoint set on line 1 of your file. You can change the line
1508 with a breakpoint set on line 1 of your file. You can change the line
1509 number for this automatic breakpoint to be <N> by using the -bN option
1509 number for this automatic breakpoint to be <N> by using the -bN option
1510 (where N must be an integer). For example:
1510 (where N must be an integer). For example:
1511
1511
1512 %run -d -b40 myscript
1512 %run -d -b40 myscript
1513
1513
1514 will set the first breakpoint at line 40 in myscript.py. Note that
1514 will set the first breakpoint at line 40 in myscript.py. Note that
1515 the first breakpoint must be set on a line which actually does
1515 the first breakpoint must be set on a line which actually does
1516 something (not a comment or docstring) for it to stop execution.
1516 something (not a comment or docstring) for it to stop execution.
1517
1517
1518 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1518 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1519 first enter 'c' (without qoutes) to start execution up to the first
1519 first enter 'c' (without qoutes) to start execution up to the first
1520 breakpoint.
1520 breakpoint.
1521
1521
1522 Entering 'help' gives information about the use of the debugger. You
1522 Entering 'help' gives information about the use of the debugger. You
1523 can easily see pdb's full documentation with "import pdb;pdb.help()"
1523 can easily see pdb's full documentation with "import pdb;pdb.help()"
1524 at a prompt.
1524 at a prompt.
1525
1525
1526 -p: run program under the control of the Python profiler module (which
1526 -p: run program under the control of the Python profiler module (which
1527 prints a detailed report of execution times, function calls, etc).
1527 prints a detailed report of execution times, function calls, etc).
1528
1528
1529 You can pass other options after -p which affect the behavior of the
1529 You can pass other options after -p which affect the behavior of the
1530 profiler itself. See the docs for %prun for details.
1530 profiler itself. See the docs for %prun for details.
1531
1531
1532 In this mode, the program's variables do NOT propagate back to the
1532 In this mode, the program's variables do NOT propagate back to the
1533 IPython interactive namespace (because they remain in the namespace
1533 IPython interactive namespace (because they remain in the namespace
1534 where the profiler executes them).
1534 where the profiler executes them).
1535
1535
1536 Internally this triggers a call to %prun, see its documentation for
1536 Internally this triggers a call to %prun, see its documentation for
1537 details on the options available specifically for profiling.
1537 details on the options available specifically for profiling.
1538
1538
1539 There is one special usage for which the text above doesn't apply:
1539 There is one special usage for which the text above doesn't apply:
1540 if the filename ends with .ipy, the file is run as ipython script,
1540 if the filename ends with .ipy, the file is run as ipython script,
1541 just as if the commands were written on IPython prompt.
1541 just as if the commands were written on IPython prompt.
1542 """
1542 """
1543
1543
1544 # get arguments and set sys.argv for program to be run.
1544 # get arguments and set sys.argv for program to be run.
1545 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1545 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1546 mode='list',list_all=1)
1546 mode='list',list_all=1)
1547
1547
1548 try:
1548 try:
1549 filename = file_finder(arg_lst[0])
1549 filename = file_finder(arg_lst[0])
1550 except IndexError:
1550 except IndexError:
1551 warn('you must provide at least a filename.')
1551 warn('you must provide at least a filename.')
1552 print '\n%run:\n',oinspect.getdoc(self.magic_run)
1552 print '\n%run:\n',oinspect.getdoc(self.magic_run)
1553 return
1553 return
1554 except IOError,msg:
1554 except IOError,msg:
1555 error(msg)
1555 error(msg)
1556 return
1556 return
1557
1557
1558 if filename.lower().endswith('.ipy'):
1558 if filename.lower().endswith('.ipy'):
1559 self.shell.safe_execfile_ipy(filename)
1559 self.shell.safe_execfile_ipy(filename)
1560 return
1560 return
1561
1561
1562 # Control the response to exit() calls made by the script being run
1562 # Control the response to exit() calls made by the script being run
1563 exit_ignore = opts.has_key('e')
1563 exit_ignore = opts.has_key('e')
1564
1564
1565 # Make sure that the running script gets a proper sys.argv as if it
1565 # Make sure that the running script gets a proper sys.argv as if it
1566 # were run from a system shell.
1566 # were run from a system shell.
1567 save_argv = sys.argv # save it for later restoring
1567 save_argv = sys.argv # save it for later restoring
1568 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1568 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1569
1569
1570 if opts.has_key('i'):
1570 if opts.has_key('i'):
1571 # Run in user's interactive namespace
1571 # Run in user's interactive namespace
1572 prog_ns = self.shell.user_ns
1572 prog_ns = self.shell.user_ns
1573 __name__save = self.shell.user_ns['__name__']
1573 __name__save = self.shell.user_ns['__name__']
1574 prog_ns['__name__'] = '__main__'
1574 prog_ns['__name__'] = '__main__'
1575 main_mod = self.shell.new_main_mod(prog_ns)
1575 main_mod = self.shell.new_main_mod(prog_ns)
1576 else:
1576 else:
1577 # Run in a fresh, empty namespace
1577 # Run in a fresh, empty namespace
1578 if opts.has_key('n'):
1578 if opts.has_key('n'):
1579 name = os.path.splitext(os.path.basename(filename))[0]
1579 name = os.path.splitext(os.path.basename(filename))[0]
1580 else:
1580 else:
1581 name = '__main__'
1581 name = '__main__'
1582
1582
1583 main_mod = self.shell.new_main_mod()
1583 main_mod = self.shell.new_main_mod()
1584 prog_ns = main_mod.__dict__
1584 prog_ns = main_mod.__dict__
1585 prog_ns['__name__'] = name
1585 prog_ns['__name__'] = name
1586
1586
1587 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1587 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1588 # set the __file__ global in the script's namespace
1588 # set the __file__ global in the script's namespace
1589 prog_ns['__file__'] = filename
1589 prog_ns['__file__'] = filename
1590
1590
1591 # pickle fix. See interactiveshell for an explanation. But we need to make sure
1591 # pickle fix. See interactiveshell for an explanation. But we need to make sure
1592 # that, if we overwrite __main__, we replace it at the end
1592 # that, if we overwrite __main__, we replace it at the end
1593 main_mod_name = prog_ns['__name__']
1593 main_mod_name = prog_ns['__name__']
1594
1594
1595 if main_mod_name == '__main__':
1595 if main_mod_name == '__main__':
1596 restore_main = sys.modules['__main__']
1596 restore_main = sys.modules['__main__']
1597 else:
1597 else:
1598 restore_main = False
1598 restore_main = False
1599
1599
1600 # This needs to be undone at the end to prevent holding references to
1600 # This needs to be undone at the end to prevent holding references to
1601 # every single object ever created.
1601 # every single object ever created.
1602 sys.modules[main_mod_name] = main_mod
1602 sys.modules[main_mod_name] = main_mod
1603
1603
1604 stats = None
1604 stats = None
1605 try:
1605 try:
1606 self.shell.save_history()
1606 #self.shell.save_history()
1607
1607
1608 if opts.has_key('p'):
1608 if opts.has_key('p'):
1609 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1609 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1610 else:
1610 else:
1611 if opts.has_key('d'):
1611 if opts.has_key('d'):
1612 deb = debugger.Pdb(self.shell.colors)
1612 deb = debugger.Pdb(self.shell.colors)
1613 # reset Breakpoint state, which is moronically kept
1613 # reset Breakpoint state, which is moronically kept
1614 # in a class
1614 # in a class
1615 bdb.Breakpoint.next = 1
1615 bdb.Breakpoint.next = 1
1616 bdb.Breakpoint.bplist = {}
1616 bdb.Breakpoint.bplist = {}
1617 bdb.Breakpoint.bpbynumber = [None]
1617 bdb.Breakpoint.bpbynumber = [None]
1618 # Set an initial breakpoint to stop execution
1618 # Set an initial breakpoint to stop execution
1619 maxtries = 10
1619 maxtries = 10
1620 bp = int(opts.get('b',[1])[0])
1620 bp = int(opts.get('b',[1])[0])
1621 checkline = deb.checkline(filename,bp)
1621 checkline = deb.checkline(filename,bp)
1622 if not checkline:
1622 if not checkline:
1623 for bp in range(bp+1,bp+maxtries+1):
1623 for bp in range(bp+1,bp+maxtries+1):
1624 if deb.checkline(filename,bp):
1624 if deb.checkline(filename,bp):
1625 break
1625 break
1626 else:
1626 else:
1627 msg = ("\nI failed to find a valid line to set "
1627 msg = ("\nI failed to find a valid line to set "
1628 "a breakpoint\n"
1628 "a breakpoint\n"
1629 "after trying up to line: %s.\n"
1629 "after trying up to line: %s.\n"
1630 "Please set a valid breakpoint manually "
1630 "Please set a valid breakpoint manually "
1631 "with the -b option." % bp)
1631 "with the -b option." % bp)
1632 error(msg)
1632 error(msg)
1633 return
1633 return
1634 # if we find a good linenumber, set the breakpoint
1634 # if we find a good linenumber, set the breakpoint
1635 deb.do_break('%s:%s' % (filename,bp))
1635 deb.do_break('%s:%s' % (filename,bp))
1636 # Start file run
1636 # Start file run
1637 print "NOTE: Enter 'c' at the",
1637 print "NOTE: Enter 'c' at the",
1638 print "%s prompt to start your script." % deb.prompt
1638 print "%s prompt to start your script." % deb.prompt
1639 try:
1639 try:
1640 deb.run('execfile("%s")' % filename,prog_ns)
1640 deb.run('execfile("%s")' % filename,prog_ns)
1641
1641
1642 except:
1642 except:
1643 etype, value, tb = sys.exc_info()
1643 etype, value, tb = sys.exc_info()
1644 # Skip three frames in the traceback: the %run one,
1644 # Skip three frames in the traceback: the %run one,
1645 # one inside bdb.py, and the command-line typed by the
1645 # one inside bdb.py, and the command-line typed by the
1646 # user (run by exec in pdb itself).
1646 # user (run by exec in pdb itself).
1647 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1647 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1648 else:
1648 else:
1649 if runner is None:
1649 if runner is None:
1650 runner = self.shell.safe_execfile
1650 runner = self.shell.safe_execfile
1651 if opts.has_key('t'):
1651 if opts.has_key('t'):
1652 # timed execution
1652 # timed execution
1653 try:
1653 try:
1654 nruns = int(opts['N'][0])
1654 nruns = int(opts['N'][0])
1655 if nruns < 1:
1655 if nruns < 1:
1656 error('Number of runs must be >=1')
1656 error('Number of runs must be >=1')
1657 return
1657 return
1658 except (KeyError):
1658 except (KeyError):
1659 nruns = 1
1659 nruns = 1
1660 if nruns == 1:
1660 if nruns == 1:
1661 t0 = clock2()
1661 t0 = clock2()
1662 runner(filename,prog_ns,prog_ns,
1662 runner(filename,prog_ns,prog_ns,
1663 exit_ignore=exit_ignore)
1663 exit_ignore=exit_ignore)
1664 t1 = clock2()
1664 t1 = clock2()
1665 t_usr = t1[0]-t0[0]
1665 t_usr = t1[0]-t0[0]
1666 t_sys = t1[1]-t0[1]
1666 t_sys = t1[1]-t0[1]
1667 print "\nIPython CPU timings (estimated):"
1667 print "\nIPython CPU timings (estimated):"
1668 print " User : %10s s." % t_usr
1668 print " User : %10s s." % t_usr
1669 print " System: %10s s." % t_sys
1669 print " System: %10s s." % t_sys
1670 else:
1670 else:
1671 runs = range(nruns)
1671 runs = range(nruns)
1672 t0 = clock2()
1672 t0 = clock2()
1673 for nr in runs:
1673 for nr in runs:
1674 runner(filename,prog_ns,prog_ns,
1674 runner(filename,prog_ns,prog_ns,
1675 exit_ignore=exit_ignore)
1675 exit_ignore=exit_ignore)
1676 t1 = clock2()
1676 t1 = clock2()
1677 t_usr = t1[0]-t0[0]
1677 t_usr = t1[0]-t0[0]
1678 t_sys = t1[1]-t0[1]
1678 t_sys = t1[1]-t0[1]
1679 print "\nIPython CPU timings (estimated):"
1679 print "\nIPython CPU timings (estimated):"
1680 print "Total runs performed:",nruns
1680 print "Total runs performed:",nruns
1681 print " Times : %10s %10s" % ('Total','Per run')
1681 print " Times : %10s %10s" % ('Total','Per run')
1682 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1682 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1683 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1683 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1684
1684
1685 else:
1685 else:
1686 # regular execution
1686 # regular execution
1687 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1687 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1688
1688
1689 if opts.has_key('i'):
1689 if opts.has_key('i'):
1690 self.shell.user_ns['__name__'] = __name__save
1690 self.shell.user_ns['__name__'] = __name__save
1691 else:
1691 else:
1692 # The shell MUST hold a reference to prog_ns so after %run
1692 # The shell MUST hold a reference to prog_ns so after %run
1693 # exits, the python deletion mechanism doesn't zero it out
1693 # exits, the python deletion mechanism doesn't zero it out
1694 # (leaving dangling references).
1694 # (leaving dangling references).
1695 self.shell.cache_main_mod(prog_ns,filename)
1695 self.shell.cache_main_mod(prog_ns,filename)
1696 # update IPython interactive namespace
1696 # update IPython interactive namespace
1697
1697
1698 # Some forms of read errors on the file may mean the
1698 # Some forms of read errors on the file may mean the
1699 # __name__ key was never set; using pop we don't have to
1699 # __name__ key was never set; using pop we don't have to
1700 # worry about a possible KeyError.
1700 # worry about a possible KeyError.
1701 prog_ns.pop('__name__', None)
1701 prog_ns.pop('__name__', None)
1702
1702
1703 self.shell.user_ns.update(prog_ns)
1703 self.shell.user_ns.update(prog_ns)
1704 finally:
1704 finally:
1705 # It's a bit of a mystery why, but __builtins__ can change from
1705 # It's a bit of a mystery why, but __builtins__ can change from
1706 # being a module to becoming a dict missing some key data after
1706 # being a module to becoming a dict missing some key data after
1707 # %run. As best I can see, this is NOT something IPython is doing
1707 # %run. As best I can see, this is NOT something IPython is doing
1708 # at all, and similar problems have been reported before:
1708 # at all, and similar problems have been reported before:
1709 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
1709 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
1710 # Since this seems to be done by the interpreter itself, the best
1710 # Since this seems to be done by the interpreter itself, the best
1711 # we can do is to at least restore __builtins__ for the user on
1711 # we can do is to at least restore __builtins__ for the user on
1712 # exit.
1712 # exit.
1713 self.shell.user_ns['__builtins__'] = __builtin__
1713 self.shell.user_ns['__builtins__'] = __builtin__
1714
1714
1715 # Ensure key global structures are restored
1715 # Ensure key global structures are restored
1716 sys.argv = save_argv
1716 sys.argv = save_argv
1717 if restore_main:
1717 if restore_main:
1718 sys.modules['__main__'] = restore_main
1718 sys.modules['__main__'] = restore_main
1719 else:
1719 else:
1720 # Remove from sys.modules the reference to main_mod we'd
1720 # Remove from sys.modules the reference to main_mod we'd
1721 # added. Otherwise it will trap references to objects
1721 # added. Otherwise it will trap references to objects
1722 # contained therein.
1722 # contained therein.
1723 del sys.modules[main_mod_name]
1723 del sys.modules[main_mod_name]
1724
1724
1725 self.shell.reload_history()
1725 #self.shell.reload_history()
1726
1726
1727 return stats
1727 return stats
1728
1728
1729 @testdec.skip_doctest
1729 @testdec.skip_doctest
1730 def magic_timeit(self, parameter_s =''):
1730 def magic_timeit(self, parameter_s =''):
1731 """Time execution of a Python statement or expression
1731 """Time execution of a Python statement or expression
1732
1732
1733 Usage:\\
1733 Usage:\\
1734 %timeit [-n<N> -r<R> [-t|-c]] statement
1734 %timeit [-n<N> -r<R> [-t|-c]] statement
1735
1735
1736 Time execution of a Python statement or expression using the timeit
1736 Time execution of a Python statement or expression using the timeit
1737 module.
1737 module.
1738
1738
1739 Options:
1739 Options:
1740 -n<N>: execute the given statement <N> times in a loop. If this value
1740 -n<N>: execute the given statement <N> times in a loop. If this value
1741 is not given, a fitting value is chosen.
1741 is not given, a fitting value is chosen.
1742
1742
1743 -r<R>: repeat the loop iteration <R> times and take the best result.
1743 -r<R>: repeat the loop iteration <R> times and take the best result.
1744 Default: 3
1744 Default: 3
1745
1745
1746 -t: use time.time to measure the time, which is the default on Unix.
1746 -t: use time.time to measure the time, which is the default on Unix.
1747 This function measures wall time.
1747 This function measures wall time.
1748
1748
1749 -c: use time.clock to measure the time, which is the default on
1749 -c: use time.clock to measure the time, which is the default on
1750 Windows and measures wall time. On Unix, resource.getrusage is used
1750 Windows and measures wall time. On Unix, resource.getrusage is used
1751 instead and returns the CPU user time.
1751 instead and returns the CPU user time.
1752
1752
1753 -p<P>: use a precision of <P> digits to display the timing result.
1753 -p<P>: use a precision of <P> digits to display the timing result.
1754 Default: 3
1754 Default: 3
1755
1755
1756
1756
1757 Examples:
1757 Examples:
1758
1758
1759 In [1]: %timeit pass
1759 In [1]: %timeit pass
1760 10000000 loops, best of 3: 53.3 ns per loop
1760 10000000 loops, best of 3: 53.3 ns per loop
1761
1761
1762 In [2]: u = None
1762 In [2]: u = None
1763
1763
1764 In [3]: %timeit u is None
1764 In [3]: %timeit u is None
1765 10000000 loops, best of 3: 184 ns per loop
1765 10000000 loops, best of 3: 184 ns per loop
1766
1766
1767 In [4]: %timeit -r 4 u == None
1767 In [4]: %timeit -r 4 u == None
1768 1000000 loops, best of 4: 242 ns per loop
1768 1000000 loops, best of 4: 242 ns per loop
1769
1769
1770 In [5]: import time
1770 In [5]: import time
1771
1771
1772 In [6]: %timeit -n1 time.sleep(2)
1772 In [6]: %timeit -n1 time.sleep(2)
1773 1 loops, best of 3: 2 s per loop
1773 1 loops, best of 3: 2 s per loop
1774
1774
1775
1775
1776 The times reported by %timeit will be slightly higher than those
1776 The times reported by %timeit will be slightly higher than those
1777 reported by the timeit.py script when variables are accessed. This is
1777 reported by the timeit.py script when variables are accessed. This is
1778 due to the fact that %timeit executes the statement in the namespace
1778 due to the fact that %timeit executes the statement in the namespace
1779 of the shell, compared with timeit.py, which uses a single setup
1779 of the shell, compared with timeit.py, which uses a single setup
1780 statement to import function or create variables. Generally, the bias
1780 statement to import function or create variables. Generally, the bias
1781 does not matter as long as results from timeit.py are not mixed with
1781 does not matter as long as results from timeit.py are not mixed with
1782 those from %timeit."""
1782 those from %timeit."""
1783
1783
1784 import timeit
1784 import timeit
1785 import math
1785 import math
1786
1786
1787 # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
1787 # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
1788 # certain terminals. Until we figure out a robust way of
1788 # certain terminals. Until we figure out a robust way of
1789 # auto-detecting if the terminal can deal with it, use plain 'us' for
1789 # auto-detecting if the terminal can deal with it, use plain 'us' for
1790 # microseconds. I am really NOT happy about disabling the proper
1790 # microseconds. I am really NOT happy about disabling the proper
1791 # 'micro' prefix, but crashing is worse... If anyone knows what the
1791 # 'micro' prefix, but crashing is worse... If anyone knows what the
1792 # right solution for this is, I'm all ears...
1792 # right solution for this is, I'm all ears...
1793 #
1793 #
1794 # Note: using
1794 # Note: using
1795 #
1795 #
1796 # s = u'\xb5'
1796 # s = u'\xb5'
1797 # s.encode(sys.getdefaultencoding())
1797 # s.encode(sys.getdefaultencoding())
1798 #
1798 #
1799 # is not sufficient, as I've seen terminals where that fails but
1799 # is not sufficient, as I've seen terminals where that fails but
1800 # print s
1800 # print s
1801 #
1801 #
1802 # succeeds
1802 # succeeds
1803 #
1803 #
1804 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1804 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1805
1805
1806 #units = [u"s", u"ms",u'\xb5',"ns"]
1806 #units = [u"s", u"ms",u'\xb5',"ns"]
1807 units = [u"s", u"ms",u'us',"ns"]
1807 units = [u"s", u"ms",u'us',"ns"]
1808
1808
1809 scaling = [1, 1e3, 1e6, 1e9]
1809 scaling = [1, 1e3, 1e6, 1e9]
1810
1810
1811 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1811 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1812 posix=False)
1812 posix=False)
1813 if stmt == "":
1813 if stmt == "":
1814 return
1814 return
1815 timefunc = timeit.default_timer
1815 timefunc = timeit.default_timer
1816 number = int(getattr(opts, "n", 0))
1816 number = int(getattr(opts, "n", 0))
1817 repeat = int(getattr(opts, "r", timeit.default_repeat))
1817 repeat = int(getattr(opts, "r", timeit.default_repeat))
1818 precision = int(getattr(opts, "p", 3))
1818 precision = int(getattr(opts, "p", 3))
1819 if hasattr(opts, "t"):
1819 if hasattr(opts, "t"):
1820 timefunc = time.time
1820 timefunc = time.time
1821 if hasattr(opts, "c"):
1821 if hasattr(opts, "c"):
1822 timefunc = clock
1822 timefunc = clock
1823
1823
1824 timer = timeit.Timer(timer=timefunc)
1824 timer = timeit.Timer(timer=timefunc)
1825 # this code has tight coupling to the inner workings of timeit.Timer,
1825 # this code has tight coupling to the inner workings of timeit.Timer,
1826 # but is there a better way to achieve that the code stmt has access
1826 # but is there a better way to achieve that the code stmt has access
1827 # to the shell namespace?
1827 # to the shell namespace?
1828
1828
1829 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1829 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1830 'setup': "pass"}
1830 'setup': "pass"}
1831 # Track compilation time so it can be reported if too long
1831 # Track compilation time so it can be reported if too long
1832 # Minimum time above which compilation time will be reported
1832 # Minimum time above which compilation time will be reported
1833 tc_min = 0.1
1833 tc_min = 0.1
1834
1834
1835 t0 = clock()
1835 t0 = clock()
1836 code = compile(src, "<magic-timeit>", "exec")
1836 code = compile(src, "<magic-timeit>", "exec")
1837 tc = clock()-t0
1837 tc = clock()-t0
1838
1838
1839 ns = {}
1839 ns = {}
1840 exec code in self.shell.user_ns, ns
1840 exec code in self.shell.user_ns, ns
1841 timer.inner = ns["inner"]
1841 timer.inner = ns["inner"]
1842
1842
1843 if number == 0:
1843 if number == 0:
1844 # determine number so that 0.2 <= total time < 2.0
1844 # determine number so that 0.2 <= total time < 2.0
1845 number = 1
1845 number = 1
1846 for i in range(1, 10):
1846 for i in range(1, 10):
1847 if timer.timeit(number) >= 0.2:
1847 if timer.timeit(number) >= 0.2:
1848 break
1848 break
1849 number *= 10
1849 number *= 10
1850
1850
1851 best = min(timer.repeat(repeat, number)) / number
1851 best = min(timer.repeat(repeat, number)) / number
1852
1852
1853 if best > 0.0 and best < 1000.0:
1853 if best > 0.0 and best < 1000.0:
1854 order = min(-int(math.floor(math.log10(best)) // 3), 3)
1854 order = min(-int(math.floor(math.log10(best)) // 3), 3)
1855 elif best >= 1000.0:
1855 elif best >= 1000.0:
1856 order = 0
1856 order = 0
1857 else:
1857 else:
1858 order = 3
1858 order = 3
1859 print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
1859 print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
1860 precision,
1860 precision,
1861 best * scaling[order],
1861 best * scaling[order],
1862 units[order])
1862 units[order])
1863 if tc > tc_min:
1863 if tc > tc_min:
1864 print "Compiler time: %.2f s" % tc
1864 print "Compiler time: %.2f s" % tc
1865
1865
1866 @testdec.skip_doctest
1866 @testdec.skip_doctest
1867 def magic_time(self,parameter_s = ''):
1867 def magic_time(self,parameter_s = ''):
1868 """Time execution of a Python statement or expression.
1868 """Time execution of a Python statement or expression.
1869
1869
1870 The CPU and wall clock times are printed, and the value of the
1870 The CPU and wall clock times are printed, and the value of the
1871 expression (if any) is returned. Note that under Win32, system time
1871 expression (if any) is returned. Note that under Win32, system time
1872 is always reported as 0, since it can not be measured.
1872 is always reported as 0, since it can not be measured.
1873
1873
1874 This function provides very basic timing functionality. In Python
1874 This function provides very basic timing functionality. In Python
1875 2.3, the timeit module offers more control and sophistication, so this
1875 2.3, the timeit module offers more control and sophistication, so this
1876 could be rewritten to use it (patches welcome).
1876 could be rewritten to use it (patches welcome).
1877
1877
1878 Some examples:
1878 Some examples:
1879
1879
1880 In [1]: time 2**128
1880 In [1]: time 2**128
1881 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1881 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1882 Wall time: 0.00
1882 Wall time: 0.00
1883 Out[1]: 340282366920938463463374607431768211456L
1883 Out[1]: 340282366920938463463374607431768211456L
1884
1884
1885 In [2]: n = 1000000
1885 In [2]: n = 1000000
1886
1886
1887 In [3]: time sum(range(n))
1887 In [3]: time sum(range(n))
1888 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1888 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1889 Wall time: 1.37
1889 Wall time: 1.37
1890 Out[3]: 499999500000L
1890 Out[3]: 499999500000L
1891
1891
1892 In [4]: time print 'hello world'
1892 In [4]: time print 'hello world'
1893 hello world
1893 hello world
1894 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1894 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1895 Wall time: 0.00
1895 Wall time: 0.00
1896
1896
1897 Note that the time needed by Python to compile the given expression
1897 Note that the time needed by Python to compile the given expression
1898 will be reported if it is more than 0.1s. In this example, the
1898 will be reported if it is more than 0.1s. In this example, the
1899 actual exponentiation is done by Python at compilation time, so while
1899 actual exponentiation is done by Python at compilation time, so while
1900 the expression can take a noticeable amount of time to compute, that
1900 the expression can take a noticeable amount of time to compute, that
1901 time is purely due to the compilation:
1901 time is purely due to the compilation:
1902
1902
1903 In [5]: time 3**9999;
1903 In [5]: time 3**9999;
1904 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1904 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1905 Wall time: 0.00 s
1905 Wall time: 0.00 s
1906
1906
1907 In [6]: time 3**999999;
1907 In [6]: time 3**999999;
1908 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1908 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1909 Wall time: 0.00 s
1909 Wall time: 0.00 s
1910 Compiler : 0.78 s
1910 Compiler : 0.78 s
1911 """
1911 """
1912
1912
1913 # fail immediately if the given expression can't be compiled
1913 # fail immediately if the given expression can't be compiled
1914
1914
1915 expr = self.shell.prefilter(parameter_s,False)
1915 expr = self.shell.prefilter(parameter_s,False)
1916
1916
1917 # Minimum time above which compilation time will be reported
1917 # Minimum time above which compilation time will be reported
1918 tc_min = 0.1
1918 tc_min = 0.1
1919
1919
1920 try:
1920 try:
1921 mode = 'eval'
1921 mode = 'eval'
1922 t0 = clock()
1922 t0 = clock()
1923 code = compile(expr,'<timed eval>',mode)
1923 code = compile(expr,'<timed eval>',mode)
1924 tc = clock()-t0
1924 tc = clock()-t0
1925 except SyntaxError:
1925 except SyntaxError:
1926 mode = 'exec'
1926 mode = 'exec'
1927 t0 = clock()
1927 t0 = clock()
1928 code = compile(expr,'<timed exec>',mode)
1928 code = compile(expr,'<timed exec>',mode)
1929 tc = clock()-t0
1929 tc = clock()-t0
1930 # skew measurement as little as possible
1930 # skew measurement as little as possible
1931 glob = self.shell.user_ns
1931 glob = self.shell.user_ns
1932 clk = clock2
1932 clk = clock2
1933 wtime = time.time
1933 wtime = time.time
1934 # time execution
1934 # time execution
1935 wall_st = wtime()
1935 wall_st = wtime()
1936 if mode=='eval':
1936 if mode=='eval':
1937 st = clk()
1937 st = clk()
1938 out = eval(code,glob)
1938 out = eval(code,glob)
1939 end = clk()
1939 end = clk()
1940 else:
1940 else:
1941 st = clk()
1941 st = clk()
1942 exec code in glob
1942 exec code in glob
1943 end = clk()
1943 end = clk()
1944 out = None
1944 out = None
1945 wall_end = wtime()
1945 wall_end = wtime()
1946 # Compute actual times and report
1946 # Compute actual times and report
1947 wall_time = wall_end-wall_st
1947 wall_time = wall_end-wall_st
1948 cpu_user = end[0]-st[0]
1948 cpu_user = end[0]-st[0]
1949 cpu_sys = end[1]-st[1]
1949 cpu_sys = end[1]-st[1]
1950 cpu_tot = cpu_user+cpu_sys
1950 cpu_tot = cpu_user+cpu_sys
1951 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1951 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1952 (cpu_user,cpu_sys,cpu_tot)
1952 (cpu_user,cpu_sys,cpu_tot)
1953 print "Wall time: %.2f s" % wall_time
1953 print "Wall time: %.2f s" % wall_time
1954 if tc > tc_min:
1954 if tc > tc_min:
1955 print "Compiler : %.2f s" % tc
1955 print "Compiler : %.2f s" % tc
1956 return out
1956 return out
1957
1957
1958 @testdec.skip_doctest
1958 @testdec.skip_doctest
1959 def magic_macro(self,parameter_s = ''):
1959 def magic_macro(self,parameter_s = ''):
1960 """Define a set of input lines as a macro for future re-execution.
1960 """Define a set of input lines as a macro for future re-execution.
1961
1961
1962 Usage:\\
1962 Usage:\\
1963 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
1963 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
1964
1964
1965 Options:
1965 Options:
1966
1966
1967 -r: use 'raw' input. By default, the 'processed' history is used,
1967 -r: use 'raw' input. By default, the 'processed' history is used,
1968 so that magics are loaded in their transformed version to valid
1968 so that magics are loaded in their transformed version to valid
1969 Python. If this option is given, the raw input as typed as the
1969 Python. If this option is given, the raw input as typed as the
1970 command line is used instead.
1970 command line is used instead.
1971
1971
1972 This will define a global variable called `name` which is a string
1972 This will define a global variable called `name` which is a string
1973 made of joining the slices and lines you specify (n1,n2,... numbers
1973 made of joining the slices and lines you specify (n1,n2,... numbers
1974 above) from your input history into a single string. This variable
1974 above) from your input history into a single string. This variable
1975 acts like an automatic function which re-executes those lines as if
1975 acts like an automatic function which re-executes those lines as if
1976 you had typed them. You just type 'name' at the prompt and the code
1976 you had typed them. You just type 'name' at the prompt and the code
1977 executes.
1977 executes.
1978
1978
1979 The notation for indicating number ranges is: n1-n2 means 'use line
1979 The notation for indicating number ranges is: n1-n2 means 'use line
1980 numbers n1,...n2' (the endpoint is included). That is, '5-7' means
1980 numbers n1,...n2' (the endpoint is included). That is, '5-7' means
1981 using the lines numbered 5,6 and 7.
1981 using the lines numbered 5,6 and 7.
1982
1982
1983 Note: as a 'hidden' feature, you can also use traditional python slice
1983 Note: as a 'hidden' feature, you can also use traditional python slice
1984 notation, where N:M means numbers N through M-1.
1984 notation, where N:M means numbers N through M-1.
1985
1985
1986 For example, if your history contains (%hist prints it):
1986 For example, if your history contains (%hist prints it):
1987
1987
1988 44: x=1
1988 44: x=1
1989 45: y=3
1989 45: y=3
1990 46: z=x+y
1990 46: z=x+y
1991 47: print x
1991 47: print x
1992 48: a=5
1992 48: a=5
1993 49: print 'x',x,'y',y
1993 49: print 'x',x,'y',y
1994
1994
1995 you can create a macro with lines 44 through 47 (included) and line 49
1995 you can create a macro with lines 44 through 47 (included) and line 49
1996 called my_macro with:
1996 called my_macro with:
1997
1997
1998 In [55]: %macro my_macro 44-47 49
1998 In [55]: %macro my_macro 44-47 49
1999
1999
2000 Now, typing `my_macro` (without quotes) will re-execute all this code
2000 Now, typing `my_macro` (without quotes) will re-execute all this code
2001 in one pass.
2001 in one pass.
2002
2002
2003 You don't need to give the line-numbers in order, and any given line
2003 You don't need to give the line-numbers in order, and any given line
2004 number can appear multiple times. You can assemble macros with any
2004 number can appear multiple times. You can assemble macros with any
2005 lines from your input history in any order.
2005 lines from your input history in any order.
2006
2006
2007 The macro is a simple object which holds its value in an attribute,
2007 The macro is a simple object which holds its value in an attribute,
2008 but IPython's display system checks for macros and executes them as
2008 but IPython's display system checks for macros and executes them as
2009 code instead of printing them when you type their name.
2009 code instead of printing them when you type their name.
2010
2010
2011 You can view a macro's contents by explicitly printing it with:
2011 You can view a macro's contents by explicitly printing it with:
2012
2012
2013 'print macro_name'.
2013 'print macro_name'.
2014
2014
2015 For one-off cases which DON'T contain magic function calls in them you
2015 For one-off cases which DON'T contain magic function calls in them you
2016 can obtain similar results by explicitly executing slices from your
2016 can obtain similar results by explicitly executing slices from your
2017 input history with:
2017 input history with:
2018
2018
2019 In [60]: exec In[44:48]+In[49]"""
2019 In [60]: exec In[44:48]+In[49]"""
2020
2020
2021 opts,args = self.parse_options(parameter_s,'r',mode='list')
2021 opts,args = self.parse_options(parameter_s,'r',mode='list')
2022 if not args: # List existing macros
2022 if not args: # List existing macros
2023 return sorted(k for k,v in self.shell.user_ns.iteritems() if\
2023 return sorted(k for k,v in self.shell.user_ns.iteritems() if\
2024 isinstance(v, Macro))
2024 isinstance(v, Macro))
2025 if len(args) == 1:
2025 if len(args) == 1:
2026 raise UsageError(
2026 raise UsageError(
2027 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
2027 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
2028 name, ranges = args[0], " ".join(args[1:])
2028 name, ranges = args[0], " ".join(args[1:])
2029
2029
2030 #print 'rng',ranges # dbg
2030 #print 'rng',ranges # dbg
2031 lines = self.extract_input_lines(ranges,'r' in opts)
2031 lines = self.extract_input_lines(ranges,'r' in opts)
2032 macro = Macro(lines)
2032 macro = Macro(lines)
2033 self.shell.define_macro(name, macro)
2033 self.shell.define_macro(name, macro)
2034 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
2034 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
2035 print 'Macro contents:'
2035 print 'Macro contents:'
2036 print macro,
2036 print macro,
2037
2037
2038 def magic_save(self,parameter_s = ''):
2038 def magic_save(self,parameter_s = ''):
2039 """Save a set of lines to a given filename.
2039 """Save a set of lines to a given filename.
2040
2040
2041 Usage:\\
2041 Usage:\\
2042 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
2042 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
2043
2043
2044 Options:
2044 Options:
2045
2045
2046 -r: use 'raw' input. By default, the 'processed' history is used,
2046 -r: use 'raw' input. By default, the 'processed' history is used,
2047 so that magics are loaded in their transformed version to valid
2047 so that magics are loaded in their transformed version to valid
2048 Python. If this option is given, the raw input as typed as the
2048 Python. If this option is given, the raw input as typed as the
2049 command line is used instead.
2049 command line is used instead.
2050
2050
2051 This function uses the same syntax as %macro for line extraction, but
2051 This function uses the same syntax as %macro for line extraction, but
2052 instead of creating a macro it saves the resulting string to the
2052 instead of creating a macro it saves the resulting string to the
2053 filename you specify.
2053 filename you specify.
2054
2054
2055 It adds a '.py' extension to the file if you don't do so yourself, and
2055 It adds a '.py' extension to the file if you don't do so yourself, and
2056 it asks for confirmation before overwriting existing files."""
2056 it asks for confirmation before overwriting existing files."""
2057
2057
2058 opts,args = self.parse_options(parameter_s,'r',mode='list')
2058 opts,args = self.parse_options(parameter_s,'r',mode='list')
2059 fname,ranges = args[0], " ".join(args[1:])
2059 fname,ranges = args[0], " ".join(args[1:])
2060 if not fname.endswith('.py'):
2060 if not fname.endswith('.py'):
2061 fname += '.py'
2061 fname += '.py'
2062 if os.path.isfile(fname):
2062 if os.path.isfile(fname):
2063 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
2063 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
2064 if ans.lower() not in ['y','yes']:
2064 if ans.lower() not in ['y','yes']:
2065 print 'Operation cancelled.'
2065 print 'Operation cancelled.'
2066 return
2066 return
2067 cmds = self.extract_input_lines(ranges, 'r' in opts)
2067 cmds = self.extract_input_lines(ranges, 'r' in opts)
2068 with open(fname,'w') as f:
2068 with open(fname,'w') as f:
2069 f.write(cmds)
2069 f.write(cmds)
2070 print 'The following commands were written to file `%s`:' % fname
2070 print 'The following commands were written to file `%s`:' % fname
2071 print cmds
2071 print cmds
2072
2072
2073 def _edit_macro(self,mname,macro):
2073 def _edit_macro(self,mname,macro):
2074 """open an editor with the macro data in a file"""
2074 """open an editor with the macro data in a file"""
2075 filename = self.shell.mktempfile(macro.value)
2075 filename = self.shell.mktempfile(macro.value)
2076 self.shell.hooks.editor(filename)
2076 self.shell.hooks.editor(filename)
2077
2077
2078 # and make a new macro object, to replace the old one
2078 # and make a new macro object, to replace the old one
2079 mfile = open(filename)
2079 mfile = open(filename)
2080 mvalue = mfile.read()
2080 mvalue = mfile.read()
2081 mfile.close()
2081 mfile.close()
2082 self.shell.user_ns[mname] = Macro(mvalue)
2082 self.shell.user_ns[mname] = Macro(mvalue)
2083
2083
2084 def magic_ed(self,parameter_s=''):
2084 def magic_ed(self,parameter_s=''):
2085 """Alias to %edit."""
2085 """Alias to %edit."""
2086 return self.magic_edit(parameter_s)
2086 return self.magic_edit(parameter_s)
2087
2087
2088 @testdec.skip_doctest
2088 @testdec.skip_doctest
2089 def magic_edit(self,parameter_s='',last_call=['','']):
2089 def magic_edit(self,parameter_s='',last_call=['','']):
2090 """Bring up an editor and execute the resulting code.
2090 """Bring up an editor and execute the resulting code.
2091
2091
2092 Usage:
2092 Usage:
2093 %edit [options] [args]
2093 %edit [options] [args]
2094
2094
2095 %edit runs IPython's editor hook. The default version of this hook is
2095 %edit runs IPython's editor hook. The default version of this hook is
2096 set to call the __IPYTHON__.rc.editor command. This is read from your
2096 set to call the __IPYTHON__.rc.editor command. This is read from your
2097 environment variable $EDITOR. If this isn't found, it will default to
2097 environment variable $EDITOR. If this isn't found, it will default to
2098 vi under Linux/Unix and to notepad under Windows. See the end of this
2098 vi under Linux/Unix and to notepad under Windows. See the end of this
2099 docstring for how to change the editor hook.
2099 docstring for how to change the editor hook.
2100
2100
2101 You can also set the value of this editor via the command line option
2101 You can also set the value of this editor via the command line option
2102 '-editor' or in your ipythonrc file. This is useful if you wish to use
2102 '-editor' or in your ipythonrc file. This is useful if you wish to use
2103 specifically for IPython an editor different from your typical default
2103 specifically for IPython an editor different from your typical default
2104 (and for Windows users who typically don't set environment variables).
2104 (and for Windows users who typically don't set environment variables).
2105
2105
2106 This command allows you to conveniently edit multi-line code right in
2106 This command allows you to conveniently edit multi-line code right in
2107 your IPython session.
2107 your IPython session.
2108
2108
2109 If called without arguments, %edit opens up an empty editor with a
2109 If called without arguments, %edit opens up an empty editor with a
2110 temporary file and will execute the contents of this file when you
2110 temporary file and will execute the contents of this file when you
2111 close it (don't forget to save it!).
2111 close it (don't forget to save it!).
2112
2112
2113
2113
2114 Options:
2114 Options:
2115
2115
2116 -n <number>: open the editor at a specified line number. By default,
2116 -n <number>: open the editor at a specified line number. By default,
2117 the IPython editor hook uses the unix syntax 'editor +N filename', but
2117 the IPython editor hook uses the unix syntax 'editor +N filename', but
2118 you can configure this by providing your own modified hook if your
2118 you can configure this by providing your own modified hook if your
2119 favorite editor supports line-number specifications with a different
2119 favorite editor supports line-number specifications with a different
2120 syntax.
2120 syntax.
2121
2121
2122 -p: this will call the editor with the same data as the previous time
2122 -p: this will call the editor with the same data as the previous time
2123 it was used, regardless of how long ago (in your current session) it
2123 it was used, regardless of how long ago (in your current session) it
2124 was.
2124 was.
2125
2125
2126 -r: use 'raw' input. This option only applies to input taken from the
2126 -r: use 'raw' input. This option only applies to input taken from the
2127 user's history. By default, the 'processed' history is used, so that
2127 user's history. By default, the 'processed' history is used, so that
2128 magics are loaded in their transformed version to valid Python. If
2128 magics are loaded in their transformed version to valid Python. If
2129 this option is given, the raw input as typed as the command line is
2129 this option is given, the raw input as typed as the command line is
2130 used instead. When you exit the editor, it will be executed by
2130 used instead. When you exit the editor, it will be executed by
2131 IPython's own processor.
2131 IPython's own processor.
2132
2132
2133 -x: do not execute the edited code immediately upon exit. This is
2133 -x: do not execute the edited code immediately upon exit. This is
2134 mainly useful if you are editing programs which need to be called with
2134 mainly useful if you are editing programs which need to be called with
2135 command line arguments, which you can then do using %run.
2135 command line arguments, which you can then do using %run.
2136
2136
2137
2137
2138 Arguments:
2138 Arguments:
2139
2139
2140 If arguments are given, the following possibilites exist:
2140 If arguments are given, the following possibilites exist:
2141
2141
2142 - The arguments are numbers or pairs of colon-separated numbers (like
2142 - The arguments are numbers or pairs of colon-separated numbers (like
2143 1 4:8 9). These are interpreted as lines of previous input to be
2143 1 4:8 9). These are interpreted as lines of previous input to be
2144 loaded into the editor. The syntax is the same of the %macro command.
2144 loaded into the editor. The syntax is the same of the %macro command.
2145
2145
2146 - If the argument doesn't start with a number, it is evaluated as a
2146 - If the argument doesn't start with a number, it is evaluated as a
2147 variable and its contents loaded into the editor. You can thus edit
2147 variable and its contents loaded into the editor. You can thus edit
2148 any string which contains python code (including the result of
2148 any string which contains python code (including the result of
2149 previous edits).
2149 previous edits).
2150
2150
2151 - If the argument is the name of an object (other than a string),
2151 - If the argument is the name of an object (other than a string),
2152 IPython will try to locate the file where it was defined and open the
2152 IPython will try to locate the file where it was defined and open the
2153 editor at the point where it is defined. You can use `%edit function`
2153 editor at the point where it is defined. You can use `%edit function`
2154 to load an editor exactly at the point where 'function' is defined,
2154 to load an editor exactly at the point where 'function' is defined,
2155 edit it and have the file be executed automatically.
2155 edit it and have the file be executed automatically.
2156
2156
2157 If the object is a macro (see %macro for details), this opens up your
2157 If the object is a macro (see %macro for details), this opens up your
2158 specified editor with a temporary file containing the macro's data.
2158 specified editor with a temporary file containing the macro's data.
2159 Upon exit, the macro is reloaded with the contents of the file.
2159 Upon exit, the macro is reloaded with the contents of the file.
2160
2160
2161 Note: opening at an exact line is only supported under Unix, and some
2161 Note: opening at an exact line is only supported under Unix, and some
2162 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2162 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2163 '+NUMBER' parameter necessary for this feature. Good editors like
2163 '+NUMBER' parameter necessary for this feature. Good editors like
2164 (X)Emacs, vi, jed, pico and joe all do.
2164 (X)Emacs, vi, jed, pico and joe all do.
2165
2165
2166 - If the argument is not found as a variable, IPython will look for a
2166 - If the argument is not found as a variable, IPython will look for a
2167 file with that name (adding .py if necessary) and load it into the
2167 file with that name (adding .py if necessary) and load it into the
2168 editor. It will execute its contents with execfile() when you exit,
2168 editor. It will execute its contents with execfile() when you exit,
2169 loading any code in the file into your interactive namespace.
2169 loading any code in the file into your interactive namespace.
2170
2170
2171 After executing your code, %edit will return as output the code you
2171 After executing your code, %edit will return as output the code you
2172 typed in the editor (except when it was an existing file). This way
2172 typed in the editor (except when it was an existing file). This way
2173 you can reload the code in further invocations of %edit as a variable,
2173 you can reload the code in further invocations of %edit as a variable,
2174 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2174 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2175 the output.
2175 the output.
2176
2176
2177 Note that %edit is also available through the alias %ed.
2177 Note that %edit is also available through the alias %ed.
2178
2178
2179 This is an example of creating a simple function inside the editor and
2179 This is an example of creating a simple function inside the editor and
2180 then modifying it. First, start up the editor:
2180 then modifying it. First, start up the editor:
2181
2181
2182 In [1]: ed
2182 In [1]: ed
2183 Editing... done. Executing edited code...
2183 Editing... done. Executing edited code...
2184 Out[1]: 'def foo():n print "foo() was defined in an editing session"n'
2184 Out[1]: 'def foo():n print "foo() was defined in an editing session"n'
2185
2185
2186 We can then call the function foo():
2186 We can then call the function foo():
2187
2187
2188 In [2]: foo()
2188 In [2]: foo()
2189 foo() was defined in an editing session
2189 foo() was defined in an editing session
2190
2190
2191 Now we edit foo. IPython automatically loads the editor with the
2191 Now we edit foo. IPython automatically loads the editor with the
2192 (temporary) file where foo() was previously defined:
2192 (temporary) file where foo() was previously defined:
2193
2193
2194 In [3]: ed foo
2194 In [3]: ed foo
2195 Editing... done. Executing edited code...
2195 Editing... done. Executing edited code...
2196
2196
2197 And if we call foo() again we get the modified version:
2197 And if we call foo() again we get the modified version:
2198
2198
2199 In [4]: foo()
2199 In [4]: foo()
2200 foo() has now been changed!
2200 foo() has now been changed!
2201
2201
2202 Here is an example of how to edit a code snippet successive
2202 Here is an example of how to edit a code snippet successive
2203 times. First we call the editor:
2203 times. First we call the editor:
2204
2204
2205 In [5]: ed
2205 In [5]: ed
2206 Editing... done. Executing edited code...
2206 Editing... done. Executing edited code...
2207 hello
2207 hello
2208 Out[5]: "print 'hello'n"
2208 Out[5]: "print 'hello'n"
2209
2209
2210 Now we call it again with the previous output (stored in _):
2210 Now we call it again with the previous output (stored in _):
2211
2211
2212 In [6]: ed _
2212 In [6]: ed _
2213 Editing... done. Executing edited code...
2213 Editing... done. Executing edited code...
2214 hello world
2214 hello world
2215 Out[6]: "print 'hello world'n"
2215 Out[6]: "print 'hello world'n"
2216
2216
2217 Now we call it with the output #8 (stored in _8, also as Out[8]):
2217 Now we call it with the output #8 (stored in _8, also as Out[8]):
2218
2218
2219 In [7]: ed _8
2219 In [7]: ed _8
2220 Editing... done. Executing edited code...
2220 Editing... done. Executing edited code...
2221 hello again
2221 hello again
2222 Out[7]: "print 'hello again'n"
2222 Out[7]: "print 'hello again'n"
2223
2223
2224
2224
2225 Changing the default editor hook:
2225 Changing the default editor hook:
2226
2226
2227 If you wish to write your own editor hook, you can put it in a
2227 If you wish to write your own editor hook, you can put it in a
2228 configuration file which you load at startup time. The default hook
2228 configuration file which you load at startup time. The default hook
2229 is defined in the IPython.core.hooks module, and you can use that as a
2229 is defined in the IPython.core.hooks module, and you can use that as a
2230 starting example for further modifications. That file also has
2230 starting example for further modifications. That file also has
2231 general instructions on how to set a new hook for use once you've
2231 general instructions on how to set a new hook for use once you've
2232 defined it."""
2232 defined it."""
2233
2233
2234 # FIXME: This function has become a convoluted mess. It needs a
2234 # FIXME: This function has become a convoluted mess. It needs a
2235 # ground-up rewrite with clean, simple logic.
2235 # ground-up rewrite with clean, simple logic.
2236
2236
2237 def make_filename(arg):
2237 def make_filename(arg):
2238 "Make a filename from the given args"
2238 "Make a filename from the given args"
2239 try:
2239 try:
2240 filename = get_py_filename(arg)
2240 filename = get_py_filename(arg)
2241 except IOError:
2241 except IOError:
2242 if args.endswith('.py'):
2242 if args.endswith('.py'):
2243 filename = arg
2243 filename = arg
2244 else:
2244 else:
2245 filename = None
2245 filename = None
2246 return filename
2246 return filename
2247
2247
2248 # custom exceptions
2248 # custom exceptions
2249 class DataIsObject(Exception): pass
2249 class DataIsObject(Exception): pass
2250
2250
2251 opts,args = self.parse_options(parameter_s,'prxn:')
2251 opts,args = self.parse_options(parameter_s,'prxn:')
2252 # Set a few locals from the options for convenience:
2252 # Set a few locals from the options for convenience:
2253 opts_prev = 'p' in opts
2253 opts_prev = 'p' in opts
2254 opts_raw = 'r' in opts
2254 opts_raw = 'r' in opts
2255
2255
2256 # Default line number value
2256 # Default line number value
2257 lineno = opts.get('n',None)
2257 lineno = opts.get('n',None)
2258
2258
2259 if opts_prev:
2259 if opts_prev:
2260 args = '_%s' % last_call[0]
2260 args = '_%s' % last_call[0]
2261 if not self.shell.user_ns.has_key(args):
2261 if not self.shell.user_ns.has_key(args):
2262 args = last_call[1]
2262 args = last_call[1]
2263
2263
2264 # use last_call to remember the state of the previous call, but don't
2264 # use last_call to remember the state of the previous call, but don't
2265 # let it be clobbered by successive '-p' calls.
2265 # let it be clobbered by successive '-p' calls.
2266 try:
2266 try:
2267 last_call[0] = self.shell.displayhook.prompt_count
2267 last_call[0] = self.shell.displayhook.prompt_count
2268 if not opts_prev:
2268 if not opts_prev:
2269 last_call[1] = parameter_s
2269 last_call[1] = parameter_s
2270 except:
2270 except:
2271 pass
2271 pass
2272
2272
2273 # by default this is done with temp files, except when the given
2273 # by default this is done with temp files, except when the given
2274 # arg is a filename
2274 # arg is a filename
2275 use_temp = True
2275 use_temp = True
2276
2276
2277 data = ''
2277 data = ''
2278 if args[0].isdigit():
2278 if args[0].isdigit():
2279 # Mode where user specifies ranges of lines, like in %macro.
2279 # Mode where user specifies ranges of lines, like in %macro.
2280 # This means that you can't edit files whose names begin with
2280 # This means that you can't edit files whose names begin with
2281 # numbers this way. Tough.
2281 # numbers this way. Tough.
2282 data = self.extract_input_lines(args, opts_raw)
2282 data = self.extract_input_lines(args, opts_raw)
2283 elif args.endswith('.py'):
2283 elif args.endswith('.py'):
2284 filename = make_filename(args)
2284 filename = make_filename(args)
2285 use_temp = False
2285 use_temp = False
2286 elif args:
2286 elif args:
2287 try:
2287 try:
2288 # Load the parameter given as a variable. If not a string,
2288 # Load the parameter given as a variable. If not a string,
2289 # process it as an object instead (below)
2289 # process it as an object instead (below)
2290
2290
2291 #print '*** args',args,'type',type(args) # dbg
2291 #print '*** args',args,'type',type(args) # dbg
2292 data = eval(args, self.shell.user_ns)
2292 data = eval(args, self.shell.user_ns)
2293 if not isinstance(data, basestring):
2293 if not isinstance(data, basestring):
2294 raise DataIsObject
2294 raise DataIsObject
2295
2295
2296 except (NameError,SyntaxError):
2296 except (NameError,SyntaxError):
2297 # given argument is not a variable, try as a filename
2297 # given argument is not a variable, try as a filename
2298 filename = make_filename(args)
2298 filename = make_filename(args)
2299 if filename is None:
2299 if filename is None:
2300 warn("Argument given (%s) can't be found as a variable "
2300 warn("Argument given (%s) can't be found as a variable "
2301 "or as a filename." % args)
2301 "or as a filename." % args)
2302 return
2302 return
2303 use_temp = False
2303 use_temp = False
2304
2304
2305 except DataIsObject:
2305 except DataIsObject:
2306 # macros have a special edit function
2306 # macros have a special edit function
2307 if isinstance(data, Macro):
2307 if isinstance(data, Macro):
2308 self._edit_macro(args,data)
2308 self._edit_macro(args,data)
2309 return
2309 return
2310
2310
2311 # For objects, try to edit the file where they are defined
2311 # For objects, try to edit the file where they are defined
2312 try:
2312 try:
2313 filename = inspect.getabsfile(data)
2313 filename = inspect.getabsfile(data)
2314 if 'fakemodule' in filename.lower() and inspect.isclass(data):
2314 if 'fakemodule' in filename.lower() and inspect.isclass(data):
2315 # class created by %edit? Try to find source
2315 # class created by %edit? Try to find source
2316 # by looking for method definitions instead, the
2316 # by looking for method definitions instead, the
2317 # __module__ in those classes is FakeModule.
2317 # __module__ in those classes is FakeModule.
2318 attrs = [getattr(data, aname) for aname in dir(data)]
2318 attrs = [getattr(data, aname) for aname in dir(data)]
2319 for attr in attrs:
2319 for attr in attrs:
2320 if not inspect.ismethod(attr):
2320 if not inspect.ismethod(attr):
2321 continue
2321 continue
2322 filename = inspect.getabsfile(attr)
2322 filename = inspect.getabsfile(attr)
2323 if filename and 'fakemodule' not in filename.lower():
2323 if filename and 'fakemodule' not in filename.lower():
2324 # change the attribute to be the edit target instead
2324 # change the attribute to be the edit target instead
2325 data = attr
2325 data = attr
2326 break
2326 break
2327
2327
2328 datafile = 1
2328 datafile = 1
2329 except TypeError:
2329 except TypeError:
2330 filename = make_filename(args)
2330 filename = make_filename(args)
2331 datafile = 1
2331 datafile = 1
2332 warn('Could not find file where `%s` is defined.\n'
2332 warn('Could not find file where `%s` is defined.\n'
2333 'Opening a file named `%s`' % (args,filename))
2333 'Opening a file named `%s`' % (args,filename))
2334 # Now, make sure we can actually read the source (if it was in
2334 # Now, make sure we can actually read the source (if it was in
2335 # a temp file it's gone by now).
2335 # a temp file it's gone by now).
2336 if datafile:
2336 if datafile:
2337 try:
2337 try:
2338 if lineno is None:
2338 if lineno is None:
2339 lineno = inspect.getsourcelines(data)[1]
2339 lineno = inspect.getsourcelines(data)[1]
2340 except IOError:
2340 except IOError:
2341 filename = make_filename(args)
2341 filename = make_filename(args)
2342 if filename is None:
2342 if filename is None:
2343 warn('The file `%s` where `%s` was defined cannot '
2343 warn('The file `%s` where `%s` was defined cannot '
2344 'be read.' % (filename,data))
2344 'be read.' % (filename,data))
2345 return
2345 return
2346 use_temp = False
2346 use_temp = False
2347
2347
2348 if use_temp:
2348 if use_temp:
2349 filename = self.shell.mktempfile(data)
2349 filename = self.shell.mktempfile(data)
2350 print 'IPython will make a temporary file named:',filename
2350 print 'IPython will make a temporary file named:',filename
2351
2351
2352 # do actual editing here
2352 # do actual editing here
2353 print 'Editing...',
2353 print 'Editing...',
2354 sys.stdout.flush()
2354 sys.stdout.flush()
2355 try:
2355 try:
2356 # Quote filenames that may have spaces in them
2356 # Quote filenames that may have spaces in them
2357 if ' ' in filename:
2357 if ' ' in filename:
2358 filename = "%s" % filename
2358 filename = "%s" % filename
2359 self.shell.hooks.editor(filename,lineno)
2359 self.shell.hooks.editor(filename,lineno)
2360 except TryNext:
2360 except TryNext:
2361 warn('Could not open editor')
2361 warn('Could not open editor')
2362 return
2362 return
2363
2363
2364 # XXX TODO: should this be generalized for all string vars?
2364 # XXX TODO: should this be generalized for all string vars?
2365 # For now, this is special-cased to blocks created by cpaste
2365 # For now, this is special-cased to blocks created by cpaste
2366 if args.strip() == 'pasted_block':
2366 if args.strip() == 'pasted_block':
2367 self.shell.user_ns['pasted_block'] = file_read(filename)
2367 self.shell.user_ns['pasted_block'] = file_read(filename)
2368
2368
2369 if 'x' in opts: # -x prevents actual execution
2369 if 'x' in opts: # -x prevents actual execution
2370 print
2370 print
2371 else:
2371 else:
2372 print 'done. Executing edited code...'
2372 print 'done. Executing edited code...'
2373 if opts_r:
2373 if opts_r:
2374 self.shell.run_cell(file_read(filename))
2374 self.shell.run_cell(file_read(filename))
2375 else:
2375 else:
2376 self.shell.safe_execfile(filename,self.shell.user_ns,
2376 self.shell.safe_execfile(filename,self.shell.user_ns,
2377 self.shell.user_ns)
2377 self.shell.user_ns)
2378
2378
2379
2379
2380 if use_temp:
2380 if use_temp:
2381 try:
2381 try:
2382 return open(filename).read()
2382 return open(filename).read()
2383 except IOError,msg:
2383 except IOError,msg:
2384 if msg.filename == filename:
2384 if msg.filename == filename:
2385 warn('File not found. Did you forget to save?')
2385 warn('File not found. Did you forget to save?')
2386 return
2386 return
2387 else:
2387 else:
2388 self.shell.showtraceback()
2388 self.shell.showtraceback()
2389
2389
2390 def magic_xmode(self,parameter_s = ''):
2390 def magic_xmode(self,parameter_s = ''):
2391 """Switch modes for the exception handlers.
2391 """Switch modes for the exception handlers.
2392
2392
2393 Valid modes: Plain, Context and Verbose.
2393 Valid modes: Plain, Context and Verbose.
2394
2394
2395 If called without arguments, acts as a toggle."""
2395 If called without arguments, acts as a toggle."""
2396
2396
2397 def xmode_switch_err(name):
2397 def xmode_switch_err(name):
2398 warn('Error changing %s exception modes.\n%s' %
2398 warn('Error changing %s exception modes.\n%s' %
2399 (name,sys.exc_info()[1]))
2399 (name,sys.exc_info()[1]))
2400
2400
2401 shell = self.shell
2401 shell = self.shell
2402 new_mode = parameter_s.strip().capitalize()
2402 new_mode = parameter_s.strip().capitalize()
2403 try:
2403 try:
2404 shell.InteractiveTB.set_mode(mode=new_mode)
2404 shell.InteractiveTB.set_mode(mode=new_mode)
2405 print 'Exception reporting mode:',shell.InteractiveTB.mode
2405 print 'Exception reporting mode:',shell.InteractiveTB.mode
2406 except:
2406 except:
2407 xmode_switch_err('user')
2407 xmode_switch_err('user')
2408
2408
2409 def magic_colors(self,parameter_s = ''):
2409 def magic_colors(self,parameter_s = ''):
2410 """Switch color scheme for prompts, info system and exception handlers.
2410 """Switch color scheme for prompts, info system and exception handlers.
2411
2411
2412 Currently implemented schemes: NoColor, Linux, LightBG.
2412 Currently implemented schemes: NoColor, Linux, LightBG.
2413
2413
2414 Color scheme names are not case-sensitive.
2414 Color scheme names are not case-sensitive.
2415
2415
2416 Examples
2416 Examples
2417 --------
2417 --------
2418 To get a plain black and white terminal::
2418 To get a plain black and white terminal::
2419
2419
2420 %colors nocolor
2420 %colors nocolor
2421 """
2421 """
2422
2422
2423 def color_switch_err(name):
2423 def color_switch_err(name):
2424 warn('Error changing %s color schemes.\n%s' %
2424 warn('Error changing %s color schemes.\n%s' %
2425 (name,sys.exc_info()[1]))
2425 (name,sys.exc_info()[1]))
2426
2426
2427
2427
2428 new_scheme = parameter_s.strip()
2428 new_scheme = parameter_s.strip()
2429 if not new_scheme:
2429 if not new_scheme:
2430 raise UsageError(
2430 raise UsageError(
2431 "%colors: you must specify a color scheme. See '%colors?'")
2431 "%colors: you must specify a color scheme. See '%colors?'")
2432 return
2432 return
2433 # local shortcut
2433 # local shortcut
2434 shell = self.shell
2434 shell = self.shell
2435
2435
2436 import IPython.utils.rlineimpl as readline
2436 import IPython.utils.rlineimpl as readline
2437
2437
2438 if not readline.have_readline and sys.platform == "win32":
2438 if not readline.have_readline and sys.platform == "win32":
2439 msg = """\
2439 msg = """\
2440 Proper color support under MS Windows requires the pyreadline library.
2440 Proper color support under MS Windows requires the pyreadline library.
2441 You can find it at:
2441 You can find it at:
2442 http://ipython.scipy.org/moin/PyReadline/Intro
2442 http://ipython.scipy.org/moin/PyReadline/Intro
2443 Gary's readline needs the ctypes module, from:
2443 Gary's readline needs the ctypes module, from:
2444 http://starship.python.net/crew/theller/ctypes
2444 http://starship.python.net/crew/theller/ctypes
2445 (Note that ctypes is already part of Python versions 2.5 and newer).
2445 (Note that ctypes is already part of Python versions 2.5 and newer).
2446
2446
2447 Defaulting color scheme to 'NoColor'"""
2447 Defaulting color scheme to 'NoColor'"""
2448 new_scheme = 'NoColor'
2448 new_scheme = 'NoColor'
2449 warn(msg)
2449 warn(msg)
2450
2450
2451 # readline option is 0
2451 # readline option is 0
2452 if not shell.has_readline:
2452 if not shell.has_readline:
2453 new_scheme = 'NoColor'
2453 new_scheme = 'NoColor'
2454
2454
2455 # Set prompt colors
2455 # Set prompt colors
2456 try:
2456 try:
2457 shell.displayhook.set_colors(new_scheme)
2457 shell.displayhook.set_colors(new_scheme)
2458 except:
2458 except:
2459 color_switch_err('prompt')
2459 color_switch_err('prompt')
2460 else:
2460 else:
2461 shell.colors = \
2461 shell.colors = \
2462 shell.displayhook.color_table.active_scheme_name
2462 shell.displayhook.color_table.active_scheme_name
2463 # Set exception colors
2463 # Set exception colors
2464 try:
2464 try:
2465 shell.InteractiveTB.set_colors(scheme = new_scheme)
2465 shell.InteractiveTB.set_colors(scheme = new_scheme)
2466 shell.SyntaxTB.set_colors(scheme = new_scheme)
2466 shell.SyntaxTB.set_colors(scheme = new_scheme)
2467 except:
2467 except:
2468 color_switch_err('exception')
2468 color_switch_err('exception')
2469
2469
2470 # Set info (for 'object?') colors
2470 # Set info (for 'object?') colors
2471 if shell.color_info:
2471 if shell.color_info:
2472 try:
2472 try:
2473 shell.inspector.set_active_scheme(new_scheme)
2473 shell.inspector.set_active_scheme(new_scheme)
2474 except:
2474 except:
2475 color_switch_err('object inspector')
2475 color_switch_err('object inspector')
2476 else:
2476 else:
2477 shell.inspector.set_active_scheme('NoColor')
2477 shell.inspector.set_active_scheme('NoColor')
2478
2478
2479 def magic_pprint(self, parameter_s=''):
2479 def magic_pprint(self, parameter_s=''):
2480 """Toggle pretty printing on/off."""
2480 """Toggle pretty printing on/off."""
2481 ptformatter = self.shell.display_formatter.formatters['text/plain']
2481 ptformatter = self.shell.display_formatter.formatters['text/plain']
2482 ptformatter.pprint = bool(1 - ptformatter.pprint)
2482 ptformatter.pprint = bool(1 - ptformatter.pprint)
2483 print 'Pretty printing has been turned', \
2483 print 'Pretty printing has been turned', \
2484 ['OFF','ON'][ptformatter.pprint]
2484 ['OFF','ON'][ptformatter.pprint]
2485
2485
2486 def magic_Exit(self, parameter_s=''):
2486 def magic_Exit(self, parameter_s=''):
2487 """Exit IPython."""
2487 """Exit IPython."""
2488
2488
2489 self.shell.ask_exit()
2489 self.shell.ask_exit()
2490
2490
2491 # Add aliases as magics so all common forms work: exit, quit, Exit, Quit.
2491 # Add aliases as magics so all common forms work: exit, quit, Exit, Quit.
2492 magic_exit = magic_quit = magic_Quit = magic_Exit
2492 magic_exit = magic_quit = magic_Quit = magic_Exit
2493
2493
2494 #......................................................................
2494 #......................................................................
2495 # Functions to implement unix shell-type things
2495 # Functions to implement unix shell-type things
2496
2496
2497 @testdec.skip_doctest
2497 @testdec.skip_doctest
2498 def magic_alias(self, parameter_s = ''):
2498 def magic_alias(self, parameter_s = ''):
2499 """Define an alias for a system command.
2499 """Define an alias for a system command.
2500
2500
2501 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2501 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2502
2502
2503 Then, typing 'alias_name params' will execute the system command 'cmd
2503 Then, typing 'alias_name params' will execute the system command 'cmd
2504 params' (from your underlying operating system).
2504 params' (from your underlying operating system).
2505
2505
2506 Aliases have lower precedence than magic functions and Python normal
2506 Aliases have lower precedence than magic functions and Python normal
2507 variables, so if 'foo' is both a Python variable and an alias, the
2507 variables, so if 'foo' is both a Python variable and an alias, the
2508 alias can not be executed until 'del foo' removes the Python variable.
2508 alias can not be executed until 'del foo' removes the Python variable.
2509
2509
2510 You can use the %l specifier in an alias definition to represent the
2510 You can use the %l specifier in an alias definition to represent the
2511 whole line when the alias is called. For example:
2511 whole line when the alias is called. For example:
2512
2512
2513 In [2]: alias bracket echo "Input in brackets: <%l>"
2513 In [2]: alias bracket echo "Input in brackets: <%l>"
2514 In [3]: bracket hello world
2514 In [3]: bracket hello world
2515 Input in brackets: <hello world>
2515 Input in brackets: <hello world>
2516
2516
2517 You can also define aliases with parameters using %s specifiers (one
2517 You can also define aliases with parameters using %s specifiers (one
2518 per parameter):
2518 per parameter):
2519
2519
2520 In [1]: alias parts echo first %s second %s
2520 In [1]: alias parts echo first %s second %s
2521 In [2]: %parts A B
2521 In [2]: %parts A B
2522 first A second B
2522 first A second B
2523 In [3]: %parts A
2523 In [3]: %parts A
2524 Incorrect number of arguments: 2 expected.
2524 Incorrect number of arguments: 2 expected.
2525 parts is an alias to: 'echo first %s second %s'
2525 parts is an alias to: 'echo first %s second %s'
2526
2526
2527 Note that %l and %s are mutually exclusive. You can only use one or
2527 Note that %l and %s are mutually exclusive. You can only use one or
2528 the other in your aliases.
2528 the other in your aliases.
2529
2529
2530 Aliases expand Python variables just like system calls using ! or !!
2530 Aliases expand Python variables just like system calls using ! or !!
2531 do: all expressions prefixed with '$' get expanded. For details of
2531 do: all expressions prefixed with '$' get expanded. For details of
2532 the semantic rules, see PEP-215:
2532 the semantic rules, see PEP-215:
2533 http://www.python.org/peps/pep-0215.html. This is the library used by
2533 http://www.python.org/peps/pep-0215.html. This is the library used by
2534 IPython for variable expansion. If you want to access a true shell
2534 IPython for variable expansion. If you want to access a true shell
2535 variable, an extra $ is necessary to prevent its expansion by IPython:
2535 variable, an extra $ is necessary to prevent its expansion by IPython:
2536
2536
2537 In [6]: alias show echo
2537 In [6]: alias show echo
2538 In [7]: PATH='A Python string'
2538 In [7]: PATH='A Python string'
2539 In [8]: show $PATH
2539 In [8]: show $PATH
2540 A Python string
2540 A Python string
2541 In [9]: show $$PATH
2541 In [9]: show $$PATH
2542 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2542 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2543
2543
2544 You can use the alias facility to acess all of $PATH. See the %rehash
2544 You can use the alias facility to acess all of $PATH. See the %rehash
2545 and %rehashx functions, which automatically create aliases for the
2545 and %rehashx functions, which automatically create aliases for the
2546 contents of your $PATH.
2546 contents of your $PATH.
2547
2547
2548 If called with no parameters, %alias prints the current alias table."""
2548 If called with no parameters, %alias prints the current alias table."""
2549
2549
2550 par = parameter_s.strip()
2550 par = parameter_s.strip()
2551 if not par:
2551 if not par:
2552 stored = self.db.get('stored_aliases', {} )
2552 stored = self.db.get('stored_aliases', {} )
2553 aliases = sorted(self.shell.alias_manager.aliases)
2553 aliases = sorted(self.shell.alias_manager.aliases)
2554 # for k, v in stored:
2554 # for k, v in stored:
2555 # atab.append(k, v[0])
2555 # atab.append(k, v[0])
2556
2556
2557 print "Total number of aliases:", len(aliases)
2557 print "Total number of aliases:", len(aliases)
2558 sys.stdout.flush()
2558 sys.stdout.flush()
2559 return aliases
2559 return aliases
2560
2560
2561 # Now try to define a new one
2561 # Now try to define a new one
2562 try:
2562 try:
2563 alias,cmd = par.split(None, 1)
2563 alias,cmd = par.split(None, 1)
2564 except:
2564 except:
2565 print oinspect.getdoc(self.magic_alias)
2565 print oinspect.getdoc(self.magic_alias)
2566 else:
2566 else:
2567 self.shell.alias_manager.soft_define_alias(alias, cmd)
2567 self.shell.alias_manager.soft_define_alias(alias, cmd)
2568 # end magic_alias
2568 # end magic_alias
2569
2569
2570 def magic_unalias(self, parameter_s = ''):
2570 def magic_unalias(self, parameter_s = ''):
2571 """Remove an alias"""
2571 """Remove an alias"""
2572
2572
2573 aname = parameter_s.strip()
2573 aname = parameter_s.strip()
2574 self.shell.alias_manager.undefine_alias(aname)
2574 self.shell.alias_manager.undefine_alias(aname)
2575 stored = self.db.get('stored_aliases', {} )
2575 stored = self.db.get('stored_aliases', {} )
2576 if aname in stored:
2576 if aname in stored:
2577 print "Removing %stored alias",aname
2577 print "Removing %stored alias",aname
2578 del stored[aname]
2578 del stored[aname]
2579 self.db['stored_aliases'] = stored
2579 self.db['stored_aliases'] = stored
2580
2580
2581 def magic_rehashx(self, parameter_s = ''):
2581 def magic_rehashx(self, parameter_s = ''):
2582 """Update the alias table with all executable files in $PATH.
2582 """Update the alias table with all executable files in $PATH.
2583
2583
2584 This version explicitly checks that every entry in $PATH is a file
2584 This version explicitly checks that every entry in $PATH is a file
2585 with execute access (os.X_OK), so it is much slower than %rehash.
2585 with execute access (os.X_OK), so it is much slower than %rehash.
2586
2586
2587 Under Windows, it checks executability as a match agains a
2587 Under Windows, it checks executability as a match agains a
2588 '|'-separated string of extensions, stored in the IPython config
2588 '|'-separated string of extensions, stored in the IPython config
2589 variable win_exec_ext. This defaults to 'exe|com|bat'.
2589 variable win_exec_ext. This defaults to 'exe|com|bat'.
2590
2590
2591 This function also resets the root module cache of module completer,
2591 This function also resets the root module cache of module completer,
2592 used on slow filesystems.
2592 used on slow filesystems.
2593 """
2593 """
2594 from IPython.core.alias import InvalidAliasError
2594 from IPython.core.alias import InvalidAliasError
2595
2595
2596 # for the benefit of module completer in ipy_completers.py
2596 # for the benefit of module completer in ipy_completers.py
2597 del self.db['rootmodules']
2597 del self.db['rootmodules']
2598
2598
2599 path = [os.path.abspath(os.path.expanduser(p)) for p in
2599 path = [os.path.abspath(os.path.expanduser(p)) for p in
2600 os.environ.get('PATH','').split(os.pathsep)]
2600 os.environ.get('PATH','').split(os.pathsep)]
2601 path = filter(os.path.isdir,path)
2601 path = filter(os.path.isdir,path)
2602
2602
2603 syscmdlist = []
2603 syscmdlist = []
2604 # Now define isexec in a cross platform manner.
2604 # Now define isexec in a cross platform manner.
2605 if os.name == 'posix':
2605 if os.name == 'posix':
2606 isexec = lambda fname:os.path.isfile(fname) and \
2606 isexec = lambda fname:os.path.isfile(fname) and \
2607 os.access(fname,os.X_OK)
2607 os.access(fname,os.X_OK)
2608 else:
2608 else:
2609 try:
2609 try:
2610 winext = os.environ['pathext'].replace(';','|').replace('.','')
2610 winext = os.environ['pathext'].replace(';','|').replace('.','')
2611 except KeyError:
2611 except KeyError:
2612 winext = 'exe|com|bat|py'
2612 winext = 'exe|com|bat|py'
2613 if 'py' not in winext:
2613 if 'py' not in winext:
2614 winext += '|py'
2614 winext += '|py'
2615 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2615 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2616 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2616 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2617 savedir = os.getcwd()
2617 savedir = os.getcwd()
2618
2618
2619 # Now walk the paths looking for executables to alias.
2619 # Now walk the paths looking for executables to alias.
2620 try:
2620 try:
2621 # write the whole loop for posix/Windows so we don't have an if in
2621 # write the whole loop for posix/Windows so we don't have an if in
2622 # the innermost part
2622 # the innermost part
2623 if os.name == 'posix':
2623 if os.name == 'posix':
2624 for pdir in path:
2624 for pdir in path:
2625 os.chdir(pdir)
2625 os.chdir(pdir)
2626 for ff in os.listdir(pdir):
2626 for ff in os.listdir(pdir):
2627 if isexec(ff):
2627 if isexec(ff):
2628 try:
2628 try:
2629 # Removes dots from the name since ipython
2629 # Removes dots from the name since ipython
2630 # will assume names with dots to be python.
2630 # will assume names with dots to be python.
2631 self.shell.alias_manager.define_alias(
2631 self.shell.alias_manager.define_alias(
2632 ff.replace('.',''), ff)
2632 ff.replace('.',''), ff)
2633 except InvalidAliasError:
2633 except InvalidAliasError:
2634 pass
2634 pass
2635 else:
2635 else:
2636 syscmdlist.append(ff)
2636 syscmdlist.append(ff)
2637 else:
2637 else:
2638 no_alias = self.shell.alias_manager.no_alias
2638 no_alias = self.shell.alias_manager.no_alias
2639 for pdir in path:
2639 for pdir in path:
2640 os.chdir(pdir)
2640 os.chdir(pdir)
2641 for ff in os.listdir(pdir):
2641 for ff in os.listdir(pdir):
2642 base, ext = os.path.splitext(ff)
2642 base, ext = os.path.splitext(ff)
2643 if isexec(ff) and base.lower() not in no_alias:
2643 if isexec(ff) and base.lower() not in no_alias:
2644 if ext.lower() == '.exe':
2644 if ext.lower() == '.exe':
2645 ff = base
2645 ff = base
2646 try:
2646 try:
2647 # Removes dots from the name since ipython
2647 # Removes dots from the name since ipython
2648 # will assume names with dots to be python.
2648 # will assume names with dots to be python.
2649 self.shell.alias_manager.define_alias(
2649 self.shell.alias_manager.define_alias(
2650 base.lower().replace('.',''), ff)
2650 base.lower().replace('.',''), ff)
2651 except InvalidAliasError:
2651 except InvalidAliasError:
2652 pass
2652 pass
2653 syscmdlist.append(ff)
2653 syscmdlist.append(ff)
2654 db = self.db
2654 db = self.db
2655 db['syscmdlist'] = syscmdlist
2655 db['syscmdlist'] = syscmdlist
2656 finally:
2656 finally:
2657 os.chdir(savedir)
2657 os.chdir(savedir)
2658
2658
2659 @testdec.skip_doctest
2659 @testdec.skip_doctest
2660 def magic_pwd(self, parameter_s = ''):
2660 def magic_pwd(self, parameter_s = ''):
2661 """Return the current working directory path.
2661 """Return the current working directory path.
2662
2662
2663 Examples
2663 Examples
2664 --------
2664 --------
2665 ::
2665 ::
2666
2666
2667 In [9]: pwd
2667 In [9]: pwd
2668 Out[9]: '/home/tsuser/sprint/ipython'
2668 Out[9]: '/home/tsuser/sprint/ipython'
2669 """
2669 """
2670 return os.getcwd()
2670 return os.getcwd()
2671
2671
2672 @testdec.skip_doctest
2672 @testdec.skip_doctest
2673 def magic_cd(self, parameter_s=''):
2673 def magic_cd(self, parameter_s=''):
2674 """Change the current working directory.
2674 """Change the current working directory.
2675
2675
2676 This command automatically maintains an internal list of directories
2676 This command automatically maintains an internal list of directories
2677 you visit during your IPython session, in the variable _dh. The
2677 you visit during your IPython session, in the variable _dh. The
2678 command %dhist shows this history nicely formatted. You can also
2678 command %dhist shows this history nicely formatted. You can also
2679 do 'cd -<tab>' to see directory history conveniently.
2679 do 'cd -<tab>' to see directory history conveniently.
2680
2680
2681 Usage:
2681 Usage:
2682
2682
2683 cd 'dir': changes to directory 'dir'.
2683 cd 'dir': changes to directory 'dir'.
2684
2684
2685 cd -: changes to the last visited directory.
2685 cd -: changes to the last visited directory.
2686
2686
2687 cd -<n>: changes to the n-th directory in the directory history.
2687 cd -<n>: changes to the n-th directory in the directory history.
2688
2688
2689 cd --foo: change to directory that matches 'foo' in history
2689 cd --foo: change to directory that matches 'foo' in history
2690
2690
2691 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2691 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2692 (note: cd <bookmark_name> is enough if there is no
2692 (note: cd <bookmark_name> is enough if there is no
2693 directory <bookmark_name>, but a bookmark with the name exists.)
2693 directory <bookmark_name>, but a bookmark with the name exists.)
2694 'cd -b <tab>' allows you to tab-complete bookmark names.
2694 'cd -b <tab>' allows you to tab-complete bookmark names.
2695
2695
2696 Options:
2696 Options:
2697
2697
2698 -q: quiet. Do not print the working directory after the cd command is
2698 -q: quiet. Do not print the working directory after the cd command is
2699 executed. By default IPython's cd command does print this directory,
2699 executed. By default IPython's cd command does print this directory,
2700 since the default prompts do not display path information.
2700 since the default prompts do not display path information.
2701
2701
2702 Note that !cd doesn't work for this purpose because the shell where
2702 Note that !cd doesn't work for this purpose because the shell where
2703 !command runs is immediately discarded after executing 'command'.
2703 !command runs is immediately discarded after executing 'command'.
2704
2704
2705 Examples
2705 Examples
2706 --------
2706 --------
2707 ::
2707 ::
2708
2708
2709 In [10]: cd parent/child
2709 In [10]: cd parent/child
2710 /home/tsuser/parent/child
2710 /home/tsuser/parent/child
2711 """
2711 """
2712
2712
2713 parameter_s = parameter_s.strip()
2713 parameter_s = parameter_s.strip()
2714 #bkms = self.shell.persist.get("bookmarks",{})
2714 #bkms = self.shell.persist.get("bookmarks",{})
2715
2715
2716 oldcwd = os.getcwd()
2716 oldcwd = os.getcwd()
2717 numcd = re.match(r'(-)(\d+)$',parameter_s)
2717 numcd = re.match(r'(-)(\d+)$',parameter_s)
2718 # jump in directory history by number
2718 # jump in directory history by number
2719 if numcd:
2719 if numcd:
2720 nn = int(numcd.group(2))
2720 nn = int(numcd.group(2))
2721 try:
2721 try:
2722 ps = self.shell.user_ns['_dh'][nn]
2722 ps = self.shell.user_ns['_dh'][nn]
2723 except IndexError:
2723 except IndexError:
2724 print 'The requested directory does not exist in history.'
2724 print 'The requested directory does not exist in history.'
2725 return
2725 return
2726 else:
2726 else:
2727 opts = {}
2727 opts = {}
2728 elif parameter_s.startswith('--'):
2728 elif parameter_s.startswith('--'):
2729 ps = None
2729 ps = None
2730 fallback = None
2730 fallback = None
2731 pat = parameter_s[2:]
2731 pat = parameter_s[2:]
2732 dh = self.shell.user_ns['_dh']
2732 dh = self.shell.user_ns['_dh']
2733 # first search only by basename (last component)
2733 # first search only by basename (last component)
2734 for ent in reversed(dh):
2734 for ent in reversed(dh):
2735 if pat in os.path.basename(ent) and os.path.isdir(ent):
2735 if pat in os.path.basename(ent) and os.path.isdir(ent):
2736 ps = ent
2736 ps = ent
2737 break
2737 break
2738
2738
2739 if fallback is None and pat in ent and os.path.isdir(ent):
2739 if fallback is None and pat in ent and os.path.isdir(ent):
2740 fallback = ent
2740 fallback = ent
2741
2741
2742 # if we have no last part match, pick the first full path match
2742 # if we have no last part match, pick the first full path match
2743 if ps is None:
2743 if ps is None:
2744 ps = fallback
2744 ps = fallback
2745
2745
2746 if ps is None:
2746 if ps is None:
2747 print "No matching entry in directory history"
2747 print "No matching entry in directory history"
2748 return
2748 return
2749 else:
2749 else:
2750 opts = {}
2750 opts = {}
2751
2751
2752
2752
2753 else:
2753 else:
2754 #turn all non-space-escaping backslashes to slashes,
2754 #turn all non-space-escaping backslashes to slashes,
2755 # for c:\windows\directory\names\
2755 # for c:\windows\directory\names\
2756 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2756 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2757 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2757 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2758 # jump to previous
2758 # jump to previous
2759 if ps == '-':
2759 if ps == '-':
2760 try:
2760 try:
2761 ps = self.shell.user_ns['_dh'][-2]
2761 ps = self.shell.user_ns['_dh'][-2]
2762 except IndexError:
2762 except IndexError:
2763 raise UsageError('%cd -: No previous directory to change to.')
2763 raise UsageError('%cd -: No previous directory to change to.')
2764 # jump to bookmark if needed
2764 # jump to bookmark if needed
2765 else:
2765 else:
2766 if not os.path.isdir(ps) or opts.has_key('b'):
2766 if not os.path.isdir(ps) or opts.has_key('b'):
2767 bkms = self.db.get('bookmarks', {})
2767 bkms = self.db.get('bookmarks', {})
2768
2768
2769 if bkms.has_key(ps):
2769 if bkms.has_key(ps):
2770 target = bkms[ps]
2770 target = bkms[ps]
2771 print '(bookmark:%s) -> %s' % (ps,target)
2771 print '(bookmark:%s) -> %s' % (ps,target)
2772 ps = target
2772 ps = target
2773 else:
2773 else:
2774 if opts.has_key('b'):
2774 if opts.has_key('b'):
2775 raise UsageError("Bookmark '%s' not found. "
2775 raise UsageError("Bookmark '%s' not found. "
2776 "Use '%%bookmark -l' to see your bookmarks." % ps)
2776 "Use '%%bookmark -l' to see your bookmarks." % ps)
2777
2777
2778 # at this point ps should point to the target dir
2778 # at this point ps should point to the target dir
2779 if ps:
2779 if ps:
2780 try:
2780 try:
2781 os.chdir(os.path.expanduser(ps))
2781 os.chdir(os.path.expanduser(ps))
2782 if hasattr(self.shell, 'term_title') and self.shell.term_title:
2782 if hasattr(self.shell, 'term_title') and self.shell.term_title:
2783 set_term_title('IPython: ' + abbrev_cwd())
2783 set_term_title('IPython: ' + abbrev_cwd())
2784 except OSError:
2784 except OSError:
2785 print sys.exc_info()[1]
2785 print sys.exc_info()[1]
2786 else:
2786 else:
2787 cwd = os.getcwd()
2787 cwd = os.getcwd()
2788 dhist = self.shell.user_ns['_dh']
2788 dhist = self.shell.user_ns['_dh']
2789 if oldcwd != cwd:
2789 if oldcwd != cwd:
2790 dhist.append(cwd)
2790 dhist.append(cwd)
2791 self.db['dhist'] = compress_dhist(dhist)[-100:]
2791 self.db['dhist'] = compress_dhist(dhist)[-100:]
2792
2792
2793 else:
2793 else:
2794 os.chdir(self.shell.home_dir)
2794 os.chdir(self.shell.home_dir)
2795 if hasattr(self.shell, 'term_title') and self.shell.term_title:
2795 if hasattr(self.shell, 'term_title') and self.shell.term_title:
2796 set_term_title('IPython: ' + '~')
2796 set_term_title('IPython: ' + '~')
2797 cwd = os.getcwd()
2797 cwd = os.getcwd()
2798 dhist = self.shell.user_ns['_dh']
2798 dhist = self.shell.user_ns['_dh']
2799
2799
2800 if oldcwd != cwd:
2800 if oldcwd != cwd:
2801 dhist.append(cwd)
2801 dhist.append(cwd)
2802 self.db['dhist'] = compress_dhist(dhist)[-100:]
2802 self.db['dhist'] = compress_dhist(dhist)[-100:]
2803 if not 'q' in opts and self.shell.user_ns['_dh']:
2803 if not 'q' in opts and self.shell.user_ns['_dh']:
2804 print self.shell.user_ns['_dh'][-1]
2804 print self.shell.user_ns['_dh'][-1]
2805
2805
2806
2806
2807 def magic_env(self, parameter_s=''):
2807 def magic_env(self, parameter_s=''):
2808 """List environment variables."""
2808 """List environment variables."""
2809
2809
2810 return os.environ.data
2810 return os.environ.data
2811
2811
2812 def magic_pushd(self, parameter_s=''):
2812 def magic_pushd(self, parameter_s=''):
2813 """Place the current dir on stack and change directory.
2813 """Place the current dir on stack and change directory.
2814
2814
2815 Usage:\\
2815 Usage:\\
2816 %pushd ['dirname']
2816 %pushd ['dirname']
2817 """
2817 """
2818
2818
2819 dir_s = self.shell.dir_stack
2819 dir_s = self.shell.dir_stack
2820 tgt = os.path.expanduser(parameter_s)
2820 tgt = os.path.expanduser(parameter_s)
2821 cwd = os.getcwd().replace(self.home_dir,'~')
2821 cwd = os.getcwd().replace(self.home_dir,'~')
2822 if tgt:
2822 if tgt:
2823 self.magic_cd(parameter_s)
2823 self.magic_cd(parameter_s)
2824 dir_s.insert(0,cwd)
2824 dir_s.insert(0,cwd)
2825 return self.magic_dirs()
2825 return self.magic_dirs()
2826
2826
2827 def magic_popd(self, parameter_s=''):
2827 def magic_popd(self, parameter_s=''):
2828 """Change to directory popped off the top of the stack.
2828 """Change to directory popped off the top of the stack.
2829 """
2829 """
2830 if not self.shell.dir_stack:
2830 if not self.shell.dir_stack:
2831 raise UsageError("%popd on empty stack")
2831 raise UsageError("%popd on empty stack")
2832 top = self.shell.dir_stack.pop(0)
2832 top = self.shell.dir_stack.pop(0)
2833 self.magic_cd(top)
2833 self.magic_cd(top)
2834 print "popd ->",top
2834 print "popd ->",top
2835
2835
2836 def magic_dirs(self, parameter_s=''):
2836 def magic_dirs(self, parameter_s=''):
2837 """Return the current directory stack."""
2837 """Return the current directory stack."""
2838
2838
2839 return self.shell.dir_stack
2839 return self.shell.dir_stack
2840
2840
2841 def magic_dhist(self, parameter_s=''):
2841 def magic_dhist(self, parameter_s=''):
2842 """Print your history of visited directories.
2842 """Print your history of visited directories.
2843
2843
2844 %dhist -> print full history\\
2844 %dhist -> print full history\\
2845 %dhist n -> print last n entries only\\
2845 %dhist n -> print last n entries only\\
2846 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2846 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2847
2847
2848 This history is automatically maintained by the %cd command, and
2848 This history is automatically maintained by the %cd command, and
2849 always available as the global list variable _dh. You can use %cd -<n>
2849 always available as the global list variable _dh. You can use %cd -<n>
2850 to go to directory number <n>.
2850 to go to directory number <n>.
2851
2851
2852 Note that most of time, you should view directory history by entering
2852 Note that most of time, you should view directory history by entering
2853 cd -<TAB>.
2853 cd -<TAB>.
2854
2854
2855 """
2855 """
2856
2856
2857 dh = self.shell.user_ns['_dh']
2857 dh = self.shell.user_ns['_dh']
2858 if parameter_s:
2858 if parameter_s:
2859 try:
2859 try:
2860 args = map(int,parameter_s.split())
2860 args = map(int,parameter_s.split())
2861 except:
2861 except:
2862 self.arg_err(Magic.magic_dhist)
2862 self.arg_err(Magic.magic_dhist)
2863 return
2863 return
2864 if len(args) == 1:
2864 if len(args) == 1:
2865 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2865 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2866 elif len(args) == 2:
2866 elif len(args) == 2:
2867 ini,fin = args
2867 ini,fin = args
2868 else:
2868 else:
2869 self.arg_err(Magic.magic_dhist)
2869 self.arg_err(Magic.magic_dhist)
2870 return
2870 return
2871 else:
2871 else:
2872 ini,fin = 0,len(dh)
2872 ini,fin = 0,len(dh)
2873 nlprint(dh,
2873 nlprint(dh,
2874 header = 'Directory history (kept in _dh)',
2874 header = 'Directory history (kept in _dh)',
2875 start=ini,stop=fin)
2875 start=ini,stop=fin)
2876
2876
2877 @testdec.skip_doctest
2877 @testdec.skip_doctest
2878 def magic_sc(self, parameter_s=''):
2878 def magic_sc(self, parameter_s=''):
2879 """Shell capture - execute a shell command and capture its output.
2879 """Shell capture - execute a shell command and capture its output.
2880
2880
2881 DEPRECATED. Suboptimal, retained for backwards compatibility.
2881 DEPRECATED. Suboptimal, retained for backwards compatibility.
2882
2882
2883 You should use the form 'var = !command' instead. Example:
2883 You should use the form 'var = !command' instead. Example:
2884
2884
2885 "%sc -l myfiles = ls ~" should now be written as
2885 "%sc -l myfiles = ls ~" should now be written as
2886
2886
2887 "myfiles = !ls ~"
2887 "myfiles = !ls ~"
2888
2888
2889 myfiles.s, myfiles.l and myfiles.n still apply as documented
2889 myfiles.s, myfiles.l and myfiles.n still apply as documented
2890 below.
2890 below.
2891
2891
2892 --
2892 --
2893 %sc [options] varname=command
2893 %sc [options] varname=command
2894
2894
2895 IPython will run the given command using commands.getoutput(), and
2895 IPython will run the given command using commands.getoutput(), and
2896 will then update the user's interactive namespace with a variable
2896 will then update the user's interactive namespace with a variable
2897 called varname, containing the value of the call. Your command can
2897 called varname, containing the value of the call. Your command can
2898 contain shell wildcards, pipes, etc.
2898 contain shell wildcards, pipes, etc.
2899
2899
2900 The '=' sign in the syntax is mandatory, and the variable name you
2900 The '=' sign in the syntax is mandatory, and the variable name you
2901 supply must follow Python's standard conventions for valid names.
2901 supply must follow Python's standard conventions for valid names.
2902
2902
2903 (A special format without variable name exists for internal use)
2903 (A special format without variable name exists for internal use)
2904
2904
2905 Options:
2905 Options:
2906
2906
2907 -l: list output. Split the output on newlines into a list before
2907 -l: list output. Split the output on newlines into a list before
2908 assigning it to the given variable. By default the output is stored
2908 assigning it to the given variable. By default the output is stored
2909 as a single string.
2909 as a single string.
2910
2910
2911 -v: verbose. Print the contents of the variable.
2911 -v: verbose. Print the contents of the variable.
2912
2912
2913 In most cases you should not need to split as a list, because the
2913 In most cases you should not need to split as a list, because the
2914 returned value is a special type of string which can automatically
2914 returned value is a special type of string which can automatically
2915 provide its contents either as a list (split on newlines) or as a
2915 provide its contents either as a list (split on newlines) or as a
2916 space-separated string. These are convenient, respectively, either
2916 space-separated string. These are convenient, respectively, either
2917 for sequential processing or to be passed to a shell command.
2917 for sequential processing or to be passed to a shell command.
2918
2918
2919 For example:
2919 For example:
2920
2920
2921 # all-random
2921 # all-random
2922
2922
2923 # Capture into variable a
2923 # Capture into variable a
2924 In [1]: sc a=ls *py
2924 In [1]: sc a=ls *py
2925
2925
2926 # a is a string with embedded newlines
2926 # a is a string with embedded newlines
2927 In [2]: a
2927 In [2]: a
2928 Out[2]: 'setup.py\\nwin32_manual_post_install.py'
2928 Out[2]: 'setup.py\\nwin32_manual_post_install.py'
2929
2929
2930 # which can be seen as a list:
2930 # which can be seen as a list:
2931 In [3]: a.l
2931 In [3]: a.l
2932 Out[3]: ['setup.py', 'win32_manual_post_install.py']
2932 Out[3]: ['setup.py', 'win32_manual_post_install.py']
2933
2933
2934 # or as a whitespace-separated string:
2934 # or as a whitespace-separated string:
2935 In [4]: a.s
2935 In [4]: a.s
2936 Out[4]: 'setup.py win32_manual_post_install.py'
2936 Out[4]: 'setup.py win32_manual_post_install.py'
2937
2937
2938 # a.s is useful to pass as a single command line:
2938 # a.s is useful to pass as a single command line:
2939 In [5]: !wc -l $a.s
2939 In [5]: !wc -l $a.s
2940 146 setup.py
2940 146 setup.py
2941 130 win32_manual_post_install.py
2941 130 win32_manual_post_install.py
2942 276 total
2942 276 total
2943
2943
2944 # while the list form is useful to loop over:
2944 # while the list form is useful to loop over:
2945 In [6]: for f in a.l:
2945 In [6]: for f in a.l:
2946 ...: !wc -l $f
2946 ...: !wc -l $f
2947 ...:
2947 ...:
2948 146 setup.py
2948 146 setup.py
2949 130 win32_manual_post_install.py
2949 130 win32_manual_post_install.py
2950
2950
2951 Similiarly, the lists returned by the -l option are also special, in
2951 Similiarly, the lists returned by the -l option are also special, in
2952 the sense that you can equally invoke the .s attribute on them to
2952 the sense that you can equally invoke the .s attribute on them to
2953 automatically get a whitespace-separated string from their contents:
2953 automatically get a whitespace-separated string from their contents:
2954
2954
2955 In [7]: sc -l b=ls *py
2955 In [7]: sc -l b=ls *py
2956
2956
2957 In [8]: b
2957 In [8]: b
2958 Out[8]: ['setup.py', 'win32_manual_post_install.py']
2958 Out[8]: ['setup.py', 'win32_manual_post_install.py']
2959
2959
2960 In [9]: b.s
2960 In [9]: b.s
2961 Out[9]: 'setup.py win32_manual_post_install.py'
2961 Out[9]: 'setup.py win32_manual_post_install.py'
2962
2962
2963 In summary, both the lists and strings used for ouptut capture have
2963 In summary, both the lists and strings used for ouptut capture have
2964 the following special attributes:
2964 the following special attributes:
2965
2965
2966 .l (or .list) : value as list.
2966 .l (or .list) : value as list.
2967 .n (or .nlstr): value as newline-separated string.
2967 .n (or .nlstr): value as newline-separated string.
2968 .s (or .spstr): value as space-separated string.
2968 .s (or .spstr): value as space-separated string.
2969 """
2969 """
2970
2970
2971 opts,args = self.parse_options(parameter_s,'lv')
2971 opts,args = self.parse_options(parameter_s,'lv')
2972 # Try to get a variable name and command to run
2972 # Try to get a variable name and command to run
2973 try:
2973 try:
2974 # the variable name must be obtained from the parse_options
2974 # the variable name must be obtained from the parse_options
2975 # output, which uses shlex.split to strip options out.
2975 # output, which uses shlex.split to strip options out.
2976 var,_ = args.split('=',1)
2976 var,_ = args.split('=',1)
2977 var = var.strip()
2977 var = var.strip()
2978 # But the the command has to be extracted from the original input
2978 # But the the command has to be extracted from the original input
2979 # parameter_s, not on what parse_options returns, to avoid the
2979 # parameter_s, not on what parse_options returns, to avoid the
2980 # quote stripping which shlex.split performs on it.
2980 # quote stripping which shlex.split performs on it.
2981 _,cmd = parameter_s.split('=',1)
2981 _,cmd = parameter_s.split('=',1)
2982 except ValueError:
2982 except ValueError:
2983 var,cmd = '',''
2983 var,cmd = '',''
2984 # If all looks ok, proceed
2984 # If all looks ok, proceed
2985 split = 'l' in opts
2985 split = 'l' in opts
2986 out = self.shell.getoutput(cmd, split=split)
2986 out = self.shell.getoutput(cmd, split=split)
2987 if opts.has_key('v'):
2987 if opts.has_key('v'):
2988 print '%s ==\n%s' % (var,pformat(out))
2988 print '%s ==\n%s' % (var,pformat(out))
2989 if var:
2989 if var:
2990 self.shell.user_ns.update({var:out})
2990 self.shell.user_ns.update({var:out})
2991 else:
2991 else:
2992 return out
2992 return out
2993
2993
2994 def magic_sx(self, parameter_s=''):
2994 def magic_sx(self, parameter_s=''):
2995 """Shell execute - run a shell command and capture its output.
2995 """Shell execute - run a shell command and capture its output.
2996
2996
2997 %sx command
2997 %sx command
2998
2998
2999 IPython will run the given command using commands.getoutput(), and
2999 IPython will run the given command using commands.getoutput(), and
3000 return the result formatted as a list (split on '\\n'). Since the
3000 return the result formatted as a list (split on '\\n'). Since the
3001 output is _returned_, it will be stored in ipython's regular output
3001 output is _returned_, it will be stored in ipython's regular output
3002 cache Out[N] and in the '_N' automatic variables.
3002 cache Out[N] and in the '_N' automatic variables.
3003
3003
3004 Notes:
3004 Notes:
3005
3005
3006 1) If an input line begins with '!!', then %sx is automatically
3006 1) If an input line begins with '!!', then %sx is automatically
3007 invoked. That is, while:
3007 invoked. That is, while:
3008 !ls
3008 !ls
3009 causes ipython to simply issue system('ls'), typing
3009 causes ipython to simply issue system('ls'), typing
3010 !!ls
3010 !!ls
3011 is a shorthand equivalent to:
3011 is a shorthand equivalent to:
3012 %sx ls
3012 %sx ls
3013
3013
3014 2) %sx differs from %sc in that %sx automatically splits into a list,
3014 2) %sx differs from %sc in that %sx automatically splits into a list,
3015 like '%sc -l'. The reason for this is to make it as easy as possible
3015 like '%sc -l'. The reason for this is to make it as easy as possible
3016 to process line-oriented shell output via further python commands.
3016 to process line-oriented shell output via further python commands.
3017 %sc is meant to provide much finer control, but requires more
3017 %sc is meant to provide much finer control, but requires more
3018 typing.
3018 typing.
3019
3019
3020 3) Just like %sc -l, this is a list with special attributes:
3020 3) Just like %sc -l, this is a list with special attributes:
3021
3021
3022 .l (or .list) : value as list.
3022 .l (or .list) : value as list.
3023 .n (or .nlstr): value as newline-separated string.
3023 .n (or .nlstr): value as newline-separated string.
3024 .s (or .spstr): value as whitespace-separated string.
3024 .s (or .spstr): value as whitespace-separated string.
3025
3025
3026 This is very useful when trying to use such lists as arguments to
3026 This is very useful when trying to use such lists as arguments to
3027 system commands."""
3027 system commands."""
3028
3028
3029 if parameter_s:
3029 if parameter_s:
3030 return self.shell.getoutput(parameter_s)
3030 return self.shell.getoutput(parameter_s)
3031
3031
3032 def magic_r(self, parameter_s=''):
3032 def magic_r(self, parameter_s=''):
3033 """Repeat previous input.
3033 """Repeat previous input.
3034
3034
3035 Note: Consider using the more powerfull %rep instead!
3035 Note: Consider using the more powerfull %rep instead!
3036
3036
3037 If given an argument, repeats the previous command which starts with
3037 If given an argument, repeats the previous command which starts with
3038 the same string, otherwise it just repeats the previous input.
3038 the same string, otherwise it just repeats the previous input.
3039
3039
3040 Shell escaped commands (with ! as first character) are not recognized
3040 Shell escaped commands (with ! as first character) are not recognized
3041 by this system, only pure python code and magic commands.
3041 by this system, only pure python code and magic commands.
3042 """
3042 """
3043
3043
3044 start = parameter_s.strip()
3044 start = parameter_s.strip()
3045 esc_magic = ESC_MAGIC
3045 esc_magic = ESC_MAGIC
3046 # Identify magic commands even if automagic is on (which means
3046 # Identify magic commands even if automagic is on (which means
3047 # the in-memory version is different from that typed by the user).
3047 # the in-memory version is different from that typed by the user).
3048 if self.shell.automagic:
3048 if self.shell.automagic:
3049 start_magic = esc_magic+start
3049 start_magic = esc_magic+start
3050 else:
3050 else:
3051 start_magic = start
3051 start_magic = start
3052 # Look through the input history in reverse
3052 # Look through the input history in reverse
3053 for n in range(len(self.shell.history_manager.input_hist_parsed)-2,0,-1):
3053 for n in range(len(self.shell.history_manager.input_hist_parsed)-2,0,-1):
3054 input = self.shell.history_manager.input_hist_parsed[n]
3054 input = self.shell.history_manager.input_hist_parsed[n]
3055 # skip plain 'r' lines so we don't recurse to infinity
3055 # skip plain 'r' lines so we don't recurse to infinity
3056 if input != '_ip.magic("r")\n' and \
3056 if input != '_ip.magic("r")\n' and \
3057 (input.startswith(start) or input.startswith(start_magic)):
3057 (input.startswith(start) or input.startswith(start_magic)):
3058 #print 'match',`input` # dbg
3058 #print 'match',`input` # dbg
3059 print 'Executing:',input,
3059 print 'Executing:',input,
3060 self.shell.run_cell(input)
3060 self.shell.run_cell(input)
3061 return
3061 return
3062 print 'No previous input matching `%s` found.' % start
3062 print 'No previous input matching `%s` found.' % start
3063
3063
3064
3064
3065 def magic_bookmark(self, parameter_s=''):
3065 def magic_bookmark(self, parameter_s=''):
3066 """Manage IPython's bookmark system.
3066 """Manage IPython's bookmark system.
3067
3067
3068 %bookmark <name> - set bookmark to current dir
3068 %bookmark <name> - set bookmark to current dir
3069 %bookmark <name> <dir> - set bookmark to <dir>
3069 %bookmark <name> <dir> - set bookmark to <dir>
3070 %bookmark -l - list all bookmarks
3070 %bookmark -l - list all bookmarks
3071 %bookmark -d <name> - remove bookmark
3071 %bookmark -d <name> - remove bookmark
3072 %bookmark -r - remove all bookmarks
3072 %bookmark -r - remove all bookmarks
3073
3073
3074 You can later on access a bookmarked folder with:
3074 You can later on access a bookmarked folder with:
3075 %cd -b <name>
3075 %cd -b <name>
3076 or simply '%cd <name>' if there is no directory called <name> AND
3076 or simply '%cd <name>' if there is no directory called <name> AND
3077 there is such a bookmark defined.
3077 there is such a bookmark defined.
3078
3078
3079 Your bookmarks persist through IPython sessions, but they are
3079 Your bookmarks persist through IPython sessions, but they are
3080 associated with each profile."""
3080 associated with each profile."""
3081
3081
3082 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3082 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3083 if len(args) > 2:
3083 if len(args) > 2:
3084 raise UsageError("%bookmark: too many arguments")
3084 raise UsageError("%bookmark: too many arguments")
3085
3085
3086 bkms = self.db.get('bookmarks',{})
3086 bkms = self.db.get('bookmarks',{})
3087
3087
3088 if opts.has_key('d'):
3088 if opts.has_key('d'):
3089 try:
3089 try:
3090 todel = args[0]
3090 todel = args[0]
3091 except IndexError:
3091 except IndexError:
3092 raise UsageError(
3092 raise UsageError(
3093 "%bookmark -d: must provide a bookmark to delete")
3093 "%bookmark -d: must provide a bookmark to delete")
3094 else:
3094 else:
3095 try:
3095 try:
3096 del bkms[todel]
3096 del bkms[todel]
3097 except KeyError:
3097 except KeyError:
3098 raise UsageError(
3098 raise UsageError(
3099 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3099 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3100
3100
3101 elif opts.has_key('r'):
3101 elif opts.has_key('r'):
3102 bkms = {}
3102 bkms = {}
3103 elif opts.has_key('l'):
3103 elif opts.has_key('l'):
3104 bks = bkms.keys()
3104 bks = bkms.keys()
3105 bks.sort()
3105 bks.sort()
3106 if bks:
3106 if bks:
3107 size = max(map(len,bks))
3107 size = max(map(len,bks))
3108 else:
3108 else:
3109 size = 0
3109 size = 0
3110 fmt = '%-'+str(size)+'s -> %s'
3110 fmt = '%-'+str(size)+'s -> %s'
3111 print 'Current bookmarks:'
3111 print 'Current bookmarks:'
3112 for bk in bks:
3112 for bk in bks:
3113 print fmt % (bk,bkms[bk])
3113 print fmt % (bk,bkms[bk])
3114 else:
3114 else:
3115 if not args:
3115 if not args:
3116 raise UsageError("%bookmark: You must specify the bookmark name")
3116 raise UsageError("%bookmark: You must specify the bookmark name")
3117 elif len(args)==1:
3117 elif len(args)==1:
3118 bkms[args[0]] = os.getcwd()
3118 bkms[args[0]] = os.getcwd()
3119 elif len(args)==2:
3119 elif len(args)==2:
3120 bkms[args[0]] = args[1]
3120 bkms[args[0]] = args[1]
3121 self.db['bookmarks'] = bkms
3121 self.db['bookmarks'] = bkms
3122
3122
3123 def magic_pycat(self, parameter_s=''):
3123 def magic_pycat(self, parameter_s=''):
3124 """Show a syntax-highlighted file through a pager.
3124 """Show a syntax-highlighted file through a pager.
3125
3125
3126 This magic is similar to the cat utility, but it will assume the file
3126 This magic is similar to the cat utility, but it will assume the file
3127 to be Python source and will show it with syntax highlighting. """
3127 to be Python source and will show it with syntax highlighting. """
3128
3128
3129 try:
3129 try:
3130 filename = get_py_filename(parameter_s)
3130 filename = get_py_filename(parameter_s)
3131 cont = file_read(filename)
3131 cont = file_read(filename)
3132 except IOError:
3132 except IOError:
3133 try:
3133 try:
3134 cont = eval(parameter_s,self.user_ns)
3134 cont = eval(parameter_s,self.user_ns)
3135 except NameError:
3135 except NameError:
3136 cont = None
3136 cont = None
3137 if cont is None:
3137 if cont is None:
3138 print "Error: no such file or variable"
3138 print "Error: no such file or variable"
3139 return
3139 return
3140
3140
3141 page.page(self.shell.pycolorize(cont))
3141 page.page(self.shell.pycolorize(cont))
3142
3142
3143 def _rerun_pasted(self):
3143 def _rerun_pasted(self):
3144 """ Rerun a previously pasted command.
3144 """ Rerun a previously pasted command.
3145 """
3145 """
3146 b = self.user_ns.get('pasted_block', None)
3146 b = self.user_ns.get('pasted_block', None)
3147 if b is None:
3147 if b is None:
3148 raise UsageError('No previous pasted block available')
3148 raise UsageError('No previous pasted block available')
3149 print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
3149 print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
3150 exec b in self.user_ns
3150 exec b in self.user_ns
3151
3151
3152 def _get_pasted_lines(self, sentinel):
3152 def _get_pasted_lines(self, sentinel):
3153 """ Yield pasted lines until the user enters the given sentinel value.
3153 """ Yield pasted lines until the user enters the given sentinel value.
3154 """
3154 """
3155 from IPython.core import interactiveshell
3155 from IPython.core import interactiveshell
3156 print "Pasting code; enter '%s' alone on the line to stop." % sentinel
3156 print "Pasting code; enter '%s' alone on the line to stop." % sentinel
3157 while True:
3157 while True:
3158 l = interactiveshell.raw_input_original(':')
3158 l = interactiveshell.raw_input_original(':')
3159 if l == sentinel:
3159 if l == sentinel:
3160 return
3160 return
3161 else:
3161 else:
3162 yield l
3162 yield l
3163
3163
3164 def _strip_pasted_lines_for_code(self, raw_lines):
3164 def _strip_pasted_lines_for_code(self, raw_lines):
3165 """ Strip non-code parts of a sequence of lines to return a block of
3165 """ Strip non-code parts of a sequence of lines to return a block of
3166 code.
3166 code.
3167 """
3167 """
3168 # Regular expressions that declare text we strip from the input:
3168 # Regular expressions that declare text we strip from the input:
3169 strip_re = [r'^\s*In \[\d+\]:', # IPython input prompt
3169 strip_re = [r'^\s*In \[\d+\]:', # IPython input prompt
3170 r'^\s*(\s?>)+', # Python input prompt
3170 r'^\s*(\s?>)+', # Python input prompt
3171 r'^\s*\.{3,}', # Continuation prompts
3171 r'^\s*\.{3,}', # Continuation prompts
3172 r'^\++',
3172 r'^\++',
3173 ]
3173 ]
3174
3174
3175 strip_from_start = map(re.compile,strip_re)
3175 strip_from_start = map(re.compile,strip_re)
3176
3176
3177 lines = []
3177 lines = []
3178 for l in raw_lines:
3178 for l in raw_lines:
3179 for pat in strip_from_start:
3179 for pat in strip_from_start:
3180 l = pat.sub('',l)
3180 l = pat.sub('',l)
3181 lines.append(l)
3181 lines.append(l)
3182
3182
3183 block = "\n".join(lines) + '\n'
3183 block = "\n".join(lines) + '\n'
3184 #print "block:\n",block
3184 #print "block:\n",block
3185 return block
3185 return block
3186
3186
3187 def _execute_block(self, block, par):
3187 def _execute_block(self, block, par):
3188 """ Execute a block, or store it in a variable, per the user's request.
3188 """ Execute a block, or store it in a variable, per the user's request.
3189 """
3189 """
3190 if not par:
3190 if not par:
3191 b = textwrap.dedent(block)
3191 b = textwrap.dedent(block)
3192 self.user_ns['pasted_block'] = b
3192 self.user_ns['pasted_block'] = b
3193 exec b in self.user_ns
3193 exec b in self.user_ns
3194 else:
3194 else:
3195 self.user_ns[par] = SList(block.splitlines())
3195 self.user_ns[par] = SList(block.splitlines())
3196 print "Block assigned to '%s'" % par
3196 print "Block assigned to '%s'" % par
3197
3197
3198 def magic_quickref(self,arg):
3198 def magic_quickref(self,arg):
3199 """ Show a quick reference sheet """
3199 """ Show a quick reference sheet """
3200 import IPython.core.usage
3200 import IPython.core.usage
3201 qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
3201 qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
3202
3202
3203 page.page(qr)
3203 page.page(qr)
3204
3204
3205 def magic_doctest_mode(self,parameter_s=''):
3205 def magic_doctest_mode(self,parameter_s=''):
3206 """Toggle doctest mode on and off.
3206 """Toggle doctest mode on and off.
3207
3207
3208 This mode is intended to make IPython behave as much as possible like a
3208 This mode is intended to make IPython behave as much as possible like a
3209 plain Python shell, from the perspective of how its prompts, exceptions
3209 plain Python shell, from the perspective of how its prompts, exceptions
3210 and output look. This makes it easy to copy and paste parts of a
3210 and output look. This makes it easy to copy and paste parts of a
3211 session into doctests. It does so by:
3211 session into doctests. It does so by:
3212
3212
3213 - Changing the prompts to the classic ``>>>`` ones.
3213 - Changing the prompts to the classic ``>>>`` ones.
3214 - Changing the exception reporting mode to 'Plain'.
3214 - Changing the exception reporting mode to 'Plain'.
3215 - Disabling pretty-printing of output.
3215 - Disabling pretty-printing of output.
3216
3216
3217 Note that IPython also supports the pasting of code snippets that have
3217 Note that IPython also supports the pasting of code snippets that have
3218 leading '>>>' and '...' prompts in them. This means that you can paste
3218 leading '>>>' and '...' prompts in them. This means that you can paste
3219 doctests from files or docstrings (even if they have leading
3219 doctests from files or docstrings (even if they have leading
3220 whitespace), and the code will execute correctly. You can then use
3220 whitespace), and the code will execute correctly. You can then use
3221 '%history -t' to see the translated history; this will give you the
3221 '%history -t' to see the translated history; this will give you the
3222 input after removal of all the leading prompts and whitespace, which
3222 input after removal of all the leading prompts and whitespace, which
3223 can be pasted back into an editor.
3223 can be pasted back into an editor.
3224
3224
3225 With these features, you can switch into this mode easily whenever you
3225 With these features, you can switch into this mode easily whenever you
3226 need to do testing and changes to doctests, without having to leave
3226 need to do testing and changes to doctests, without having to leave
3227 your existing IPython session.
3227 your existing IPython session.
3228 """
3228 """
3229
3229
3230 from IPython.utils.ipstruct import Struct
3230 from IPython.utils.ipstruct import Struct
3231
3231
3232 # Shorthands
3232 # Shorthands
3233 shell = self.shell
3233 shell = self.shell
3234 oc = shell.displayhook
3234 oc = shell.displayhook
3235 meta = shell.meta
3235 meta = shell.meta
3236 disp_formatter = self.shell.display_formatter
3236 disp_formatter = self.shell.display_formatter
3237 ptformatter = disp_formatter.formatters['text/plain']
3237 ptformatter = disp_formatter.formatters['text/plain']
3238 # dstore is a data store kept in the instance metadata bag to track any
3238 # dstore is a data store kept in the instance metadata bag to track any
3239 # changes we make, so we can undo them later.
3239 # changes we make, so we can undo them later.
3240 dstore = meta.setdefault('doctest_mode',Struct())
3240 dstore = meta.setdefault('doctest_mode',Struct())
3241 save_dstore = dstore.setdefault
3241 save_dstore = dstore.setdefault
3242
3242
3243 # save a few values we'll need to recover later
3243 # save a few values we'll need to recover later
3244 mode = save_dstore('mode',False)
3244 mode = save_dstore('mode',False)
3245 save_dstore('rc_pprint',ptformatter.pprint)
3245 save_dstore('rc_pprint',ptformatter.pprint)
3246 save_dstore('xmode',shell.InteractiveTB.mode)
3246 save_dstore('xmode',shell.InteractiveTB.mode)
3247 save_dstore('rc_separate_out',shell.separate_out)
3247 save_dstore('rc_separate_out',shell.separate_out)
3248 save_dstore('rc_separate_out2',shell.separate_out2)
3248 save_dstore('rc_separate_out2',shell.separate_out2)
3249 save_dstore('rc_prompts_pad_left',shell.prompts_pad_left)
3249 save_dstore('rc_prompts_pad_left',shell.prompts_pad_left)
3250 save_dstore('rc_separate_in',shell.separate_in)
3250 save_dstore('rc_separate_in',shell.separate_in)
3251 save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
3251 save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
3252
3252
3253 if mode == False:
3253 if mode == False:
3254 # turn on
3254 # turn on
3255 oc.prompt1.p_template = '>>> '
3255 oc.prompt1.p_template = '>>> '
3256 oc.prompt2.p_template = '... '
3256 oc.prompt2.p_template = '... '
3257 oc.prompt_out.p_template = ''
3257 oc.prompt_out.p_template = ''
3258
3258
3259 # Prompt separators like plain python
3259 # Prompt separators like plain python
3260 oc.input_sep = oc.prompt1.sep = ''
3260 oc.input_sep = oc.prompt1.sep = ''
3261 oc.output_sep = ''
3261 oc.output_sep = ''
3262 oc.output_sep2 = ''
3262 oc.output_sep2 = ''
3263
3263
3264 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3264 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3265 oc.prompt_out.pad_left = False
3265 oc.prompt_out.pad_left = False
3266
3266
3267 ptformatter.pprint = False
3267 ptformatter.pprint = False
3268 disp_formatter.plain_text_only = True
3268 disp_formatter.plain_text_only = True
3269
3269
3270 shell.magic_xmode('Plain')
3270 shell.magic_xmode('Plain')
3271 else:
3271 else:
3272 # turn off
3272 # turn off
3273 oc.prompt1.p_template = shell.prompt_in1
3273 oc.prompt1.p_template = shell.prompt_in1
3274 oc.prompt2.p_template = shell.prompt_in2
3274 oc.prompt2.p_template = shell.prompt_in2
3275 oc.prompt_out.p_template = shell.prompt_out
3275 oc.prompt_out.p_template = shell.prompt_out
3276
3276
3277 oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
3277 oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
3278
3278
3279 oc.output_sep = dstore.rc_separate_out
3279 oc.output_sep = dstore.rc_separate_out
3280 oc.output_sep2 = dstore.rc_separate_out2
3280 oc.output_sep2 = dstore.rc_separate_out2
3281
3281
3282 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3282 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3283 oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
3283 oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
3284
3284
3285 ptformatter.pprint = dstore.rc_pprint
3285 ptformatter.pprint = dstore.rc_pprint
3286 disp_formatter.plain_text_only = dstore.rc_plain_text_only
3286 disp_formatter.plain_text_only = dstore.rc_plain_text_only
3287
3287
3288 shell.magic_xmode(dstore.xmode)
3288 shell.magic_xmode(dstore.xmode)
3289
3289
3290 # Store new mode and inform
3290 # Store new mode and inform
3291 dstore.mode = bool(1-int(mode))
3291 dstore.mode = bool(1-int(mode))
3292 mode_label = ['OFF','ON'][dstore.mode]
3292 mode_label = ['OFF','ON'][dstore.mode]
3293 print 'Doctest mode is:', mode_label
3293 print 'Doctest mode is:', mode_label
3294
3294
3295 def magic_gui(self, parameter_s=''):
3295 def magic_gui(self, parameter_s=''):
3296 """Enable or disable IPython GUI event loop integration.
3296 """Enable or disable IPython GUI event loop integration.
3297
3297
3298 %gui [GUINAME]
3298 %gui [GUINAME]
3299
3299
3300 This magic replaces IPython's threaded shells that were activated
3300 This magic replaces IPython's threaded shells that were activated
3301 using the (pylab/wthread/etc.) command line flags. GUI toolkits
3301 using the (pylab/wthread/etc.) command line flags. GUI toolkits
3302 can now be enabled, disabled and swtiched at runtime and keyboard
3302 can now be enabled, disabled and swtiched at runtime and keyboard
3303 interrupts should work without any problems. The following toolkits
3303 interrupts should work without any problems. The following toolkits
3304 are supported: wxPython, PyQt4, PyGTK, and Tk::
3304 are supported: wxPython, PyQt4, PyGTK, and Tk::
3305
3305
3306 %gui wx # enable wxPython event loop integration
3306 %gui wx # enable wxPython event loop integration
3307 %gui qt4|qt # enable PyQt4 event loop integration
3307 %gui qt4|qt # enable PyQt4 event loop integration
3308 %gui gtk # enable PyGTK event loop integration
3308 %gui gtk # enable PyGTK event loop integration
3309 %gui tk # enable Tk event loop integration
3309 %gui tk # enable Tk event loop integration
3310 %gui # disable all event loop integration
3310 %gui # disable all event loop integration
3311
3311
3312 WARNING: after any of these has been called you can simply create
3312 WARNING: after any of these has been called you can simply create
3313 an application object, but DO NOT start the event loop yourself, as
3313 an application object, but DO NOT start the event loop yourself, as
3314 we have already handled that.
3314 we have already handled that.
3315 """
3315 """
3316 from IPython.lib.inputhook import enable_gui
3316 from IPython.lib.inputhook import enable_gui
3317 opts, arg = self.parse_options(parameter_s, '')
3317 opts, arg = self.parse_options(parameter_s, '')
3318 if arg=='': arg = None
3318 if arg=='': arg = None
3319 return enable_gui(arg)
3319 return enable_gui(arg)
3320
3320
3321 def magic_load_ext(self, module_str):
3321 def magic_load_ext(self, module_str):
3322 """Load an IPython extension by its module name."""
3322 """Load an IPython extension by its module name."""
3323 return self.extension_manager.load_extension(module_str)
3323 return self.extension_manager.load_extension(module_str)
3324
3324
3325 def magic_unload_ext(self, module_str):
3325 def magic_unload_ext(self, module_str):
3326 """Unload an IPython extension by its module name."""
3326 """Unload an IPython extension by its module name."""
3327 self.extension_manager.unload_extension(module_str)
3327 self.extension_manager.unload_extension(module_str)
3328
3328
3329 def magic_reload_ext(self, module_str):
3329 def magic_reload_ext(self, module_str):
3330 """Reload an IPython extension by its module name."""
3330 """Reload an IPython extension by its module name."""
3331 self.extension_manager.reload_extension(module_str)
3331 self.extension_manager.reload_extension(module_str)
3332
3332
3333 @testdec.skip_doctest
3333 @testdec.skip_doctest
3334 def magic_install_profiles(self, s):
3334 def magic_install_profiles(self, s):
3335 """Install the default IPython profiles into the .ipython dir.
3335 """Install the default IPython profiles into the .ipython dir.
3336
3336
3337 If the default profiles have already been installed, they will not
3337 If the default profiles have already been installed, they will not
3338 be overwritten. You can force overwriting them by using the ``-o``
3338 be overwritten. You can force overwriting them by using the ``-o``
3339 option::
3339 option::
3340
3340
3341 In [1]: %install_profiles -o
3341 In [1]: %install_profiles -o
3342 """
3342 """
3343 if '-o' in s:
3343 if '-o' in s:
3344 overwrite = True
3344 overwrite = True
3345 else:
3345 else:
3346 overwrite = False
3346 overwrite = False
3347 from IPython.config import profile
3347 from IPython.config import profile
3348 profile_dir = os.path.split(profile.__file__)[0]
3348 profile_dir = os.path.split(profile.__file__)[0]
3349 ipython_dir = self.ipython_dir
3349 ipython_dir = self.ipython_dir
3350 files = os.listdir(profile_dir)
3350 files = os.listdir(profile_dir)
3351
3351
3352 to_install = []
3352 to_install = []
3353 for f in files:
3353 for f in files:
3354 if f.startswith('ipython_config'):
3354 if f.startswith('ipython_config'):
3355 src = os.path.join(profile_dir, f)
3355 src = os.path.join(profile_dir, f)
3356 dst = os.path.join(ipython_dir, f)
3356 dst = os.path.join(ipython_dir, f)
3357 if (not os.path.isfile(dst)) or overwrite:
3357 if (not os.path.isfile(dst)) or overwrite:
3358 to_install.append((f, src, dst))
3358 to_install.append((f, src, dst))
3359 if len(to_install)>0:
3359 if len(to_install)>0:
3360 print "Installing profiles to: ", ipython_dir
3360 print "Installing profiles to: ", ipython_dir
3361 for (f, src, dst) in to_install:
3361 for (f, src, dst) in to_install:
3362 shutil.copy(src, dst)
3362 shutil.copy(src, dst)
3363 print " %s" % f
3363 print " %s" % f
3364
3364
3365 def magic_install_default_config(self, s):
3365 def magic_install_default_config(self, s):
3366 """Install IPython's default config file into the .ipython dir.
3366 """Install IPython's default config file into the .ipython dir.
3367
3367
3368 If the default config file (:file:`ipython_config.py`) is already
3368 If the default config file (:file:`ipython_config.py`) is already
3369 installed, it will not be overwritten. You can force overwriting
3369 installed, it will not be overwritten. You can force overwriting
3370 by using the ``-o`` option::
3370 by using the ``-o`` option::
3371
3371
3372 In [1]: %install_default_config
3372 In [1]: %install_default_config
3373 """
3373 """
3374 if '-o' in s:
3374 if '-o' in s:
3375 overwrite = True
3375 overwrite = True
3376 else:
3376 else:
3377 overwrite = False
3377 overwrite = False
3378 from IPython.config import default
3378 from IPython.config import default
3379 config_dir = os.path.split(default.__file__)[0]
3379 config_dir = os.path.split(default.__file__)[0]
3380 ipython_dir = self.ipython_dir
3380 ipython_dir = self.ipython_dir
3381 default_config_file_name = 'ipython_config.py'
3381 default_config_file_name = 'ipython_config.py'
3382 src = os.path.join(config_dir, default_config_file_name)
3382 src = os.path.join(config_dir, default_config_file_name)
3383 dst = os.path.join(ipython_dir, default_config_file_name)
3383 dst = os.path.join(ipython_dir, default_config_file_name)
3384 if (not os.path.isfile(dst)) or overwrite:
3384 if (not os.path.isfile(dst)) or overwrite:
3385 shutil.copy(src, dst)
3385 shutil.copy(src, dst)
3386 print "Installing default config file: %s" % dst
3386 print "Installing default config file: %s" % dst
3387
3387
3388 # Pylab support: simple wrappers that activate pylab, load gui input
3388 # Pylab support: simple wrappers that activate pylab, load gui input
3389 # handling and modify slightly %run
3389 # handling and modify slightly %run
3390
3390
3391 @testdec.skip_doctest
3391 @testdec.skip_doctest
3392 def _pylab_magic_run(self, parameter_s=''):
3392 def _pylab_magic_run(self, parameter_s=''):
3393 Magic.magic_run(self, parameter_s,
3393 Magic.magic_run(self, parameter_s,
3394 runner=mpl_runner(self.shell.safe_execfile))
3394 runner=mpl_runner(self.shell.safe_execfile))
3395
3395
3396 _pylab_magic_run.__doc__ = magic_run.__doc__
3396 _pylab_magic_run.__doc__ = magic_run.__doc__
3397
3397
3398 @testdec.skip_doctest
3398 @testdec.skip_doctest
3399 def magic_pylab(self, s):
3399 def magic_pylab(self, s):
3400 """Load numpy and matplotlib to work interactively.
3400 """Load numpy and matplotlib to work interactively.
3401
3401
3402 %pylab [GUINAME]
3402 %pylab [GUINAME]
3403
3403
3404 This function lets you activate pylab (matplotlib, numpy and
3404 This function lets you activate pylab (matplotlib, numpy and
3405 interactive support) at any point during an IPython session.
3405 interactive support) at any point during an IPython session.
3406
3406
3407 It will import at the top level numpy as np, pyplot as plt, matplotlib,
3407 It will import at the top level numpy as np, pyplot as plt, matplotlib,
3408 pylab and mlab, as well as all names from numpy and pylab.
3408 pylab and mlab, as well as all names from numpy and pylab.
3409
3409
3410 Parameters
3410 Parameters
3411 ----------
3411 ----------
3412 guiname : optional
3412 guiname : optional
3413 One of the valid arguments to the %gui magic ('qt', 'wx', 'gtk' or
3413 One of the valid arguments to the %gui magic ('qt', 'wx', 'gtk' or
3414 'tk'). If given, the corresponding Matplotlib backend is used,
3414 'tk'). If given, the corresponding Matplotlib backend is used,
3415 otherwise matplotlib's default (which you can override in your
3415 otherwise matplotlib's default (which you can override in your
3416 matplotlib config file) is used.
3416 matplotlib config file) is used.
3417
3417
3418 Examples
3418 Examples
3419 --------
3419 --------
3420 In this case, where the MPL default is TkAgg:
3420 In this case, where the MPL default is TkAgg:
3421 In [2]: %pylab
3421 In [2]: %pylab
3422
3422
3423 Welcome to pylab, a matplotlib-based Python environment.
3423 Welcome to pylab, a matplotlib-based Python environment.
3424 Backend in use: TkAgg
3424 Backend in use: TkAgg
3425 For more information, type 'help(pylab)'.
3425 For more information, type 'help(pylab)'.
3426
3426
3427 But you can explicitly request a different backend:
3427 But you can explicitly request a different backend:
3428 In [3]: %pylab qt
3428 In [3]: %pylab qt
3429
3429
3430 Welcome to pylab, a matplotlib-based Python environment.
3430 Welcome to pylab, a matplotlib-based Python environment.
3431 Backend in use: Qt4Agg
3431 Backend in use: Qt4Agg
3432 For more information, type 'help(pylab)'.
3432 For more information, type 'help(pylab)'.
3433 """
3433 """
3434 self.shell.enable_pylab(s)
3434 self.shell.enable_pylab(s)
3435
3435
3436 def magic_tb(self, s):
3436 def magic_tb(self, s):
3437 """Print the last traceback with the currently active exception mode.
3437 """Print the last traceback with the currently active exception mode.
3438
3438
3439 See %xmode for changing exception reporting modes."""
3439 See %xmode for changing exception reporting modes."""
3440 self.shell.showtraceback()
3440 self.shell.showtraceback()
3441
3441
3442 @testdec.skip_doctest
3442 @testdec.skip_doctest
3443 def magic_precision(self, s=''):
3443 def magic_precision(self, s=''):
3444 """Set floating point precision for pretty printing.
3444 """Set floating point precision for pretty printing.
3445
3445
3446 Can set either integer precision or a format string.
3446 Can set either integer precision or a format string.
3447
3447
3448 If numpy has been imported and precision is an int,
3448 If numpy has been imported and precision is an int,
3449 numpy display precision will also be set, via ``numpy.set_printoptions``.
3449 numpy display precision will also be set, via ``numpy.set_printoptions``.
3450
3450
3451 If no argument is given, defaults will be restored.
3451 If no argument is given, defaults will be restored.
3452
3452
3453 Examples
3453 Examples
3454 --------
3454 --------
3455 ::
3455 ::
3456
3456
3457 In [1]: from math import pi
3457 In [1]: from math import pi
3458
3458
3459 In [2]: %precision 3
3459 In [2]: %precision 3
3460 Out[2]: '%.3f'
3460 Out[2]: '%.3f'
3461
3461
3462 In [3]: pi
3462 In [3]: pi
3463 Out[3]: 3.142
3463 Out[3]: 3.142
3464
3464
3465 In [4]: %precision %i
3465 In [4]: %precision %i
3466 Out[4]: '%i'
3466 Out[4]: '%i'
3467
3467
3468 In [5]: pi
3468 In [5]: pi
3469 Out[5]: 3
3469 Out[5]: 3
3470
3470
3471 In [6]: %precision %e
3471 In [6]: %precision %e
3472 Out[6]: '%e'
3472 Out[6]: '%e'
3473
3473
3474 In [7]: pi**10
3474 In [7]: pi**10
3475 Out[7]: 9.364805e+04
3475 Out[7]: 9.364805e+04
3476
3476
3477 In [8]: %precision
3477 In [8]: %precision
3478 Out[8]: '%r'
3478 Out[8]: '%r'
3479
3479
3480 In [9]: pi**10
3480 In [9]: pi**10
3481 Out[9]: 93648.047476082982
3481 Out[9]: 93648.047476082982
3482
3482
3483 """
3483 """
3484
3484
3485 ptformatter = self.shell.display_formatter.formatters['text/plain']
3485 ptformatter = self.shell.display_formatter.formatters['text/plain']
3486 ptformatter.float_precision = s
3486 ptformatter.float_precision = s
3487 return ptformatter.float_format
3487 return ptformatter.float_format
3488
3488
3489 # end Magic
3489 # end Magic
@@ -1,65 +1,74 b''
1 """Tests for the IPython tab-completion machinery.
1 """Tests for the IPython tab-completion machinery.
2 """
2 """
3 #-----------------------------------------------------------------------------
3 #-----------------------------------------------------------------------------
4 # Module imports
4 # Module imports
5 #-----------------------------------------------------------------------------
5 #-----------------------------------------------------------------------------
6
6
7 # stdlib
7 # stdlib
8 import os
8 import os
9 import sys
9 import sys
10 import unittest
10 import unittest
11
11
12 # third party
12 # third party
13 import nose.tools as nt
13 import nose.tools as nt
14
14
15 # our own packages
15 # our own packages
16 from IPython.utils.tempdir import TemporaryDirectory
16 from IPython.utils.tempdir import TemporaryDirectory
17 from IPython.core.history import HistoryManager
17 from IPython.core.history import HistoryManager, extract_hist_ranges
18
18
19 def test_history():
19 def test_history():
20
20
21 ip = get_ipython()
21 ip = get_ipython()
22 with TemporaryDirectory() as tmpdir:
22 with TemporaryDirectory() as tmpdir:
23 #tmpdir = '/software/temp'
23 #tmpdir = '/software/temp'
24 histfile = os.path.realpath(os.path.join(tmpdir, 'history.json'))
24 histfile = os.path.realpath(os.path.join(tmpdir, 'history.sqlite'))
25 # Ensure that we restore the history management that we mess with in
25 # Ensure that we restore the history management that we mess with in
26 # this test doesn't affect the IPython instance used by the test suite
26 # this test doesn't affect the IPython instance used by the test suite
27 # beyond this test.
27 # beyond this test.
28 hist_manager_ori = ip.history_manager
28 hist_manager_ori = ip.history_manager
29 try:
29 try:
30 ip.history_manager = HistoryManager(ip)
30 ip.history_manager = HistoryManager(shell=ip)
31 ip.history_manager.hist_file = histfile
31 ip.history_manager.hist_file = histfile
32 ip.history_manager.init_db() # Has to be called after changing file
32 print 'test',histfile
33 print 'test',histfile
33 hist = ['a=1', 'def f():\n test = 1\n return test', 'b=2']
34 hist = ['a=1', 'def f():\n test = 1\n return test', 'b=2']
34 # test save and load
35 for i, h in enumerate(hist, start=1):
35 ip.history_manager.input_hist_raw[:] = []
36 ip.history_manager.store_inputs(i, h)
36 for h in hist:
37
37 ip.history_manager.store_inputs(h)
38 nt.assert_equal(ip.history_manager.input_hist_raw, [''] + hist)
38 ip.save_history()
39
39 ip.history_manager.input_hist_raw[:] = []
40 # Check lines were written to DB
40 ip.reload_history()
41 c = ip.history_manager.db.execute("SELECT source_raw FROM history")
41 print type(ip.history_manager.input_hist_raw)
42 nt.assert_equal([x for x, in c], hist)
42 print ip.history_manager.input_hist_raw
43 nt.assert_equal(len(ip.history_manager.input_hist_raw), len(hist))
44 for i,h in enumerate(hist):
45 nt.assert_equal(hist[i], ip.history_manager.input_hist_raw[i])
46
43
47 # Test that session offset works.
44 # New session
48 ip.history_manager.session_offset = \
45 ip.history_manager.reset()
49 len(ip.history_manager.input_hist_raw) -1
50 newcmds = ["z=5","class X(object):\n pass", "k='p'"]
46 newcmds = ["z=5","class X(object):\n pass", "k='p'"]
51 for cmd in newcmds:
47 for i, cmd in enumerate(newcmds):
52 ip.history_manager.store_inputs(cmd)
48 ip.history_manager.store_inputs(i, cmd)
53 gothist = ip.history_manager.get_history((1,4),
49 gothist = ip.history_manager.get_history(start=1, stop=4)
54 raw=True, output=False)
50 nt.assert_equal(list(gothist), zip([0,0,0],[1,2,3], newcmds))
55 nt.assert_equal(gothist, dict(zip([1,2,3], newcmds)))
51 # Previous session:
52 gothist = ip.history_manager.get_history(-1, 1, 4)
53 nt.assert_equal(list(gothist), zip([1,1,1],[1,2,3], hist))
56
54
57 # Cross testing: check that magic %save picks up on the session
55 # Cross testing: check that magic %save can get previous session.
58 # offset.
59 testfilename = os.path.realpath(os.path.join(tmpdir, "test.py"))
56 testfilename = os.path.realpath(os.path.join(tmpdir, "test.py"))
60 ip.magic_save(testfilename + " 1-3")
57 ip.magic_save(testfilename + " ~1/1-3")
61 testfile = open(testfilename, "r")
58 testfile = open(testfilename, "r")
62 nt.assert_equal(testfile.read(), "\n".join(newcmds))
59 nt.assert_equal(testfile.read(), "\n".join(hist))
63 finally:
60 finally:
64 # Restore history manager
61 # Restore history manager
65 ip.history_manager = hist_manager_ori
62 ip.history_manager = hist_manager_ori
63
64 def test_extract_hist_ranges():
65 instr = "1 2/3 ~4/5-6 ~4/7-~4/9 ~9/2-~7/5"
66 expected = [(0, 1, 2), # 0 == current session
67 (2, 3, 4),
68 (-4, 5, 7),
69 (-4, 7, 10),
70 (-9, 2, None), # None == to end
71 (-8, 1, None),
72 (-7, 1, 6)]
73 actual = list(extract_hist_ranges(instr))
74 nt.assert_equal(actual, expected)
@@ -1,420 +1,398 b''
1 """Tests for various magic functions.
1 """Tests for various magic functions.
2
2
3 Needs to be run by nose (to make ipython session available).
3 Needs to be run by nose (to make ipython session available).
4 """
4 """
5 from __future__ import absolute_import
5 from __future__ import absolute_import
6
6
7 #-----------------------------------------------------------------------------
7 #-----------------------------------------------------------------------------
8 # Imports
8 # Imports
9 #-----------------------------------------------------------------------------
9 #-----------------------------------------------------------------------------
10
10
11 import os
11 import os
12 import sys
12 import sys
13 import tempfile
13 import tempfile
14 import types
14 import types
15 from cStringIO import StringIO
15 from cStringIO import StringIO
16
16
17 import nose.tools as nt
17 import nose.tools as nt
18
18
19 from IPython.utils.path import get_long_path_name
19 from IPython.utils.path import get_long_path_name
20 from IPython.testing import decorators as dec
20 from IPython.testing import decorators as dec
21 from IPython.testing import tools as tt
21 from IPython.testing import tools as tt
22
22
23 #-----------------------------------------------------------------------------
23 #-----------------------------------------------------------------------------
24 # Test functions begin
24 # Test functions begin
25 #-----------------------------------------------------------------------------
25 #-----------------------------------------------------------------------------
26 def test_rehashx():
26 def test_rehashx():
27 # clear up everything
27 # clear up everything
28 _ip = get_ipython()
28 _ip = get_ipython()
29 _ip.alias_manager.alias_table.clear()
29 _ip.alias_manager.alias_table.clear()
30 del _ip.db['syscmdlist']
30 del _ip.db['syscmdlist']
31
31
32 _ip.magic('rehashx')
32 _ip.magic('rehashx')
33 # Practically ALL ipython development systems will have more than 10 aliases
33 # Practically ALL ipython development systems will have more than 10 aliases
34
34
35 yield (nt.assert_true, len(_ip.alias_manager.alias_table) > 10)
35 yield (nt.assert_true, len(_ip.alias_manager.alias_table) > 10)
36 for key, val in _ip.alias_manager.alias_table.iteritems():
36 for key, val in _ip.alias_manager.alias_table.iteritems():
37 # we must strip dots from alias names
37 # we must strip dots from alias names
38 nt.assert_true('.' not in key)
38 nt.assert_true('.' not in key)
39
39
40 # rehashx must fill up syscmdlist
40 # rehashx must fill up syscmdlist
41 scoms = _ip.db['syscmdlist']
41 scoms = _ip.db['syscmdlist']
42 yield (nt.assert_true, len(scoms) > 10)
42 yield (nt.assert_true, len(scoms) > 10)
43
43
44
44
45 def test_magic_parse_options():
45 def test_magic_parse_options():
46 """Test that we don't mangle paths when parsing magic options."""
46 """Test that we don't mangle paths when parsing magic options."""
47 ip = get_ipython()
47 ip = get_ipython()
48 path = 'c:\\x'
48 path = 'c:\\x'
49 opts = ip.parse_options('-f %s' % path,'f:')[0]
49 opts = ip.parse_options('-f %s' % path,'f:')[0]
50 # argv splitting is os-dependent
50 # argv splitting is os-dependent
51 if os.name == 'posix':
51 if os.name == 'posix':
52 expected = 'c:x'
52 expected = 'c:x'
53 else:
53 else:
54 expected = path
54 expected = path
55 nt.assert_equals(opts['f'], expected)
55 nt.assert_equals(opts['f'], expected)
56
56
57
57
58 def doctest_hist_f():
58 def doctest_hist_f():
59 """Test %hist -f with temporary filename.
59 """Test %hist -f with temporary filename.
60
60
61 In [9]: import tempfile
61 In [9]: import tempfile
62
62
63 In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
63 In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
64
64
65 In [11]: %hist -n -f $tfile 3
65 In [11]: %hist -nl -f $tfile 3
66
66
67 In [13]: import os; os.unlink(tfile)
67 In [13]: import os; os.unlink(tfile)
68 """
68 """
69
69
70
70
71 def doctest_hist_r():
71 def doctest_hist_r():
72 """Test %hist -r
72 """Test %hist -r
73
73
74 XXX - This test is not recording the output correctly. For some reason, in
74 XXX - This test is not recording the output correctly. For some reason, in
75 testing mode the raw history isn't getting populated. No idea why.
75 testing mode the raw history isn't getting populated. No idea why.
76 Disabling the output checking for now, though at least we do run it.
76 Disabling the output checking for now, though at least we do run it.
77
77
78 In [1]: 'hist' in _ip.lsmagic()
78 In [1]: 'hist' in _ip.lsmagic()
79 Out[1]: True
79 Out[1]: True
80
80
81 In [2]: x=1
81 In [2]: x=1
82
82
83 In [3]: %hist -r 2
83 In [3]: %hist -rl 2
84 x=1 # random
84 x=1 # random
85 %hist -r 2
85 %hist -r 2
86 """
86 """
87
87
88 def doctest_hist_op():
88 def doctest_hist_op():
89 """Test %hist -op
89 """Test %hist -op
90
90
91 In [1]: class b:
91 In [1]: class b:
92 ...: pass
92 ...: pass
93 ...:
93 ...:
94
94
95 In [2]: class s(b):
95 In [2]: class s(b):
96 ...: def __str__(self):
96 ...: def __str__(self):
97 ...: return 's'
97 ...: return 's'
98 ...:
98 ...:
99
99
100 In [3]:
100 In [3]:
101
101
102 In [4]: class r(b):
102 In [4]: class r(b):
103 ...: def __repr__(self):
103 ...: def __repr__(self):
104 ...: return 'r'
104 ...: return 'r'
105 ...:
105 ...:
106
106
107 In [5]: class sr(s,r): pass
107 In [5]: class sr(s,r): pass
108 ...:
108 ...:
109
109
110 In [6]:
110 In [6]:
111
111
112 In [7]: bb=b()
112 In [7]: bb=b()
113
113
114 In [8]: ss=s()
114 In [8]: ss=s()
115
115
116 In [9]: rr=r()
116 In [9]: rr=r()
117
117
118 In [10]: ssrr=sr()
118 In [10]: ssrr=sr()
119
119
120 In [11]: bb
120 In [11]: bb
121 Out[11]: <...b instance at ...>
121 Out[11]: <...b instance at ...>
122
122
123 In [12]: ss
123 In [12]: ss
124 Out[12]: <...s instance at ...>
124 Out[12]: <...s instance at ...>
125
125
126 In [13]:
126 In [13]:
127
127
128 In [14]: %hist -op
128 In [14]: %hist -op
129 >>> class b:
129 >>> class b:
130 ... pass
130 ... pass
131 ...
131 ...
132 >>> class s(b):
132 >>> class s(b):
133 ... def __str__(self):
133 ... def __str__(self):
134 ... return 's'
134 ... return 's'
135 ...
135 ...
136 >>>
136 >>>
137 >>> class r(b):
137 >>> class r(b):
138 ... def __repr__(self):
138 ... def __repr__(self):
139 ... return 'r'
139 ... return 'r'
140 ...
140 ...
141 >>> class sr(s,r): pass
141 >>> class sr(s,r): pass
142 >>>
142 >>>
143 >>> bb=b()
143 >>> bb=b()
144 >>> ss=s()
144 >>> ss=s()
145 >>> rr=r()
145 >>> rr=r()
146 >>> ssrr=sr()
146 >>> ssrr=sr()
147 >>> bb
147 >>> bb
148 <...b instance at ...>
148 <...b instance at ...>
149 >>> ss
149 >>> ss
150 <...s instance at ...>
150 <...s instance at ...>
151 >>>
151 >>>
152 """
152 """
153
153
154 def test_shist():
155 # Simple tests of ShadowHist class - test generator.
156 import os, shutil, tempfile
157
158 from IPython.utils import pickleshare
159 from IPython.core.history import ShadowHist
160
161 tfile = tempfile.mktemp('','tmp-ipython-')
162
163 db = pickleshare.PickleShareDB(tfile)
164 s = ShadowHist(db, get_ipython())
165 s.add('hello')
166 s.add('world')
167 s.add('hello')
168 s.add('hello')
169 s.add('karhu')
170
171 yield nt.assert_equals,s.all(),[(1, 'hello'), (2, 'world'), (3, 'karhu')]
172
173 yield nt.assert_equal,s.get(2),'world'
174
175 shutil.rmtree(tfile)
176
177 def test_macro():
154 def test_macro():
178 ip = get_ipython()
155 ip = get_ipython()
179 ip.history_manager.reset() # Clear any existing history.
156 ip.history_manager.reset() # Clear any existing history.
180 cmds = ["a=1", "def b():\n return a**2", "print(a,b())"]
157 cmds = ["a=1", "def b():\n return a**2", "print(a,b())"]
181 for cmd in cmds:
158 for i, cmd in enumerate(cmds, start=1):
182 ip.history_manager.store_inputs(cmd)
159 ip.history_manager.store_inputs(i, cmd)
160 print i, cmd
183 ip.magic("macro test 1-3")
161 ip.magic("macro test 1-3")
184 nt.assert_equal(ip.user_ns["test"].value, "\n".join(cmds)+"\n")
162 nt.assert_equal(ip.user_ns["test"].value, "\n".join(cmds)+"\n")
185
163
186 # List macros.
164 # List macros.
187 assert "test" in ip.magic("macro")
165 assert "test" in ip.magic("macro")
188
166
189
167
190 # XXX failing for now, until we get clearcmd out of quarantine. But we should
168 # XXX failing for now, until we get clearcmd out of quarantine. But we should
191 # fix this and revert the skip to happen only if numpy is not around.
169 # fix this and revert the skip to happen only if numpy is not around.
192 #@dec.skipif_not_numpy
170 #@dec.skipif_not_numpy
193 @dec.skip_known_failure
171 @dec.skip_known_failure
194 def test_numpy_clear_array_undec():
172 def test_numpy_clear_array_undec():
195 from IPython.extensions import clearcmd
173 from IPython.extensions import clearcmd
196
174
197 _ip.ex('import numpy as np')
175 _ip.ex('import numpy as np')
198 _ip.ex('a = np.empty(2)')
176 _ip.ex('a = np.empty(2)')
199 yield (nt.assert_true, 'a' in _ip.user_ns)
177 yield (nt.assert_true, 'a' in _ip.user_ns)
200 _ip.magic('clear array')
178 _ip.magic('clear array')
201 yield (nt.assert_false, 'a' in _ip.user_ns)
179 yield (nt.assert_false, 'a' in _ip.user_ns)
202
180
203
181
204 # Multiple tests for clipboard pasting
182 # Multiple tests for clipboard pasting
205 @dec.parametric
183 @dec.parametric
206 def test_paste():
184 def test_paste():
207 _ip = get_ipython()
185 _ip = get_ipython()
208 def paste(txt, flags='-q'):
186 def paste(txt, flags='-q'):
209 """Paste input text, by default in quiet mode"""
187 """Paste input text, by default in quiet mode"""
210 hooks.clipboard_get = lambda : txt
188 hooks.clipboard_get = lambda : txt
211 _ip.magic('paste '+flags)
189 _ip.magic('paste '+flags)
212
190
213 # Inject fake clipboard hook but save original so we can restore it later
191 # Inject fake clipboard hook but save original so we can restore it later
214 hooks = _ip.hooks
192 hooks = _ip.hooks
215 user_ns = _ip.user_ns
193 user_ns = _ip.user_ns
216 original_clip = hooks.clipboard_get
194 original_clip = hooks.clipboard_get
217
195
218 try:
196 try:
219 # This try/except with an emtpy except clause is here only because
197 # This try/except with an emtpy except clause is here only because
220 # try/yield/finally is invalid syntax in Python 2.4. This will be
198 # try/yield/finally is invalid syntax in Python 2.4. This will be
221 # removed when we drop 2.4-compatibility, and the emtpy except below
199 # removed when we drop 2.4-compatibility, and the emtpy except below
222 # will be changed to a finally.
200 # will be changed to a finally.
223
201
224 # Run tests with fake clipboard function
202 # Run tests with fake clipboard function
225 user_ns.pop('x', None)
203 user_ns.pop('x', None)
226 paste('x=1')
204 paste('x=1')
227 yield nt.assert_equal(user_ns['x'], 1)
205 yield nt.assert_equal(user_ns['x'], 1)
228
206
229 user_ns.pop('x', None)
207 user_ns.pop('x', None)
230 paste('>>> x=2')
208 paste('>>> x=2')
231 yield nt.assert_equal(user_ns['x'], 2)
209 yield nt.assert_equal(user_ns['x'], 2)
232
210
233 paste("""
211 paste("""
234 >>> x = [1,2,3]
212 >>> x = [1,2,3]
235 >>> y = []
213 >>> y = []
236 >>> for i in x:
214 >>> for i in x:
237 ... y.append(i**2)
215 ... y.append(i**2)
238 ...
216 ...
239 """)
217 """)
240 yield nt.assert_equal(user_ns['x'], [1,2,3])
218 yield nt.assert_equal(user_ns['x'], [1,2,3])
241 yield nt.assert_equal(user_ns['y'], [1,4,9])
219 yield nt.assert_equal(user_ns['y'], [1,4,9])
242
220
243 # Now, test that paste -r works
221 # Now, test that paste -r works
244 user_ns.pop('x', None)
222 user_ns.pop('x', None)
245 yield nt.assert_false('x' in user_ns)
223 yield nt.assert_false('x' in user_ns)
246 _ip.magic('paste -r')
224 _ip.magic('paste -r')
247 yield nt.assert_equal(user_ns['x'], [1,2,3])
225 yield nt.assert_equal(user_ns['x'], [1,2,3])
248
226
249 # Also test paste echoing, by temporarily faking the writer
227 # Also test paste echoing, by temporarily faking the writer
250 w = StringIO()
228 w = StringIO()
251 writer = _ip.write
229 writer = _ip.write
252 _ip.write = w.write
230 _ip.write = w.write
253 code = """
231 code = """
254 a = 100
232 a = 100
255 b = 200"""
233 b = 200"""
256 try:
234 try:
257 paste(code,'')
235 paste(code,'')
258 out = w.getvalue()
236 out = w.getvalue()
259 finally:
237 finally:
260 _ip.write = writer
238 _ip.write = writer
261 yield nt.assert_equal(user_ns['a'], 100)
239 yield nt.assert_equal(user_ns['a'], 100)
262 yield nt.assert_equal(user_ns['b'], 200)
240 yield nt.assert_equal(user_ns['b'], 200)
263 yield nt.assert_equal(out, code+"\n## -- End pasted text --\n")
241 yield nt.assert_equal(out, code+"\n## -- End pasted text --\n")
264
242
265 finally:
243 finally:
266 # This should be in a finally clause, instead of the bare except above.
244 # This should be in a finally clause, instead of the bare except above.
267 # Restore original hook
245 # Restore original hook
268 hooks.clipboard_get = original_clip
246 hooks.clipboard_get = original_clip
269
247
270
248
271 def test_time():
249 def test_time():
272 _ip.magic('time None')
250 _ip.magic('time None')
273
251
274
252
275 def doctest_time():
253 def doctest_time():
276 """
254 """
277 In [10]: %time None
255 In [10]: %time None
278 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
256 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
279 Wall time: 0.00 s
257 Wall time: 0.00 s
280 """
258 """
281
259
282
260
283 def test_doctest_mode():
261 def test_doctest_mode():
284 "Toggle doctest_mode twice, it should be a no-op and run without error"
262 "Toggle doctest_mode twice, it should be a no-op and run without error"
285 _ip.magic('doctest_mode')
263 _ip.magic('doctest_mode')
286 _ip.magic('doctest_mode')
264 _ip.magic('doctest_mode')
287
265
288
266
289 def test_parse_options():
267 def test_parse_options():
290 """Tests for basic options parsing in magics."""
268 """Tests for basic options parsing in magics."""
291 # These are only the most minimal of tests, more should be added later. At
269 # These are only the most minimal of tests, more should be added later. At
292 # the very least we check that basic text/unicode calls work OK.
270 # the very least we check that basic text/unicode calls work OK.
293 nt.assert_equal(_ip.parse_options('foo', '')[1], 'foo')
271 nt.assert_equal(_ip.parse_options('foo', '')[1], 'foo')
294 nt.assert_equal(_ip.parse_options(u'foo', '')[1], u'foo')
272 nt.assert_equal(_ip.parse_options(u'foo', '')[1], u'foo')
295
273
296
274
297 def test_dirops():
275 def test_dirops():
298 """Test various directory handling operations."""
276 """Test various directory handling operations."""
299 curpath = lambda :os.path.splitdrive(os.getcwd())[1].replace('\\','/')
277 curpath = lambda :os.path.splitdrive(os.getcwd())[1].replace('\\','/')
300
278
301 startdir = os.getcwd()
279 startdir = os.getcwd()
302 ipdir = _ip.ipython_dir
280 ipdir = _ip.ipython_dir
303 try:
281 try:
304 _ip.magic('cd "%s"' % ipdir)
282 _ip.magic('cd "%s"' % ipdir)
305 nt.assert_equal(curpath(), ipdir)
283 nt.assert_equal(curpath(), ipdir)
306 _ip.magic('cd -')
284 _ip.magic('cd -')
307 nt.assert_equal(curpath(), startdir)
285 nt.assert_equal(curpath(), startdir)
308 _ip.magic('pushd "%s"' % ipdir)
286 _ip.magic('pushd "%s"' % ipdir)
309 nt.assert_equal(curpath(), ipdir)
287 nt.assert_equal(curpath(), ipdir)
310 _ip.magic('popd')
288 _ip.magic('popd')
311 nt.assert_equal(curpath(), startdir)
289 nt.assert_equal(curpath(), startdir)
312 finally:
290 finally:
313 os.chdir(startdir)
291 os.chdir(startdir)
314
292
315
293
316 def check_cpaste(code, should_fail=False):
294 def check_cpaste(code, should_fail=False):
317 """Execute code via 'cpaste' and ensure it was executed, unless
295 """Execute code via 'cpaste' and ensure it was executed, unless
318 should_fail is set.
296 should_fail is set.
319 """
297 """
320 _ip.user_ns['code_ran'] = False
298 _ip.user_ns['code_ran'] = False
321
299
322 src = StringIO()
300 src = StringIO()
323 src.write('\n')
301 src.write('\n')
324 src.write(code)
302 src.write(code)
325 src.write('\n--\n')
303 src.write('\n--\n')
326 src.seek(0)
304 src.seek(0)
327
305
328 stdin_save = sys.stdin
306 stdin_save = sys.stdin
329 sys.stdin = src
307 sys.stdin = src
330
308
331 try:
309 try:
332 _ip.magic('cpaste')
310 _ip.magic('cpaste')
333 except:
311 except:
334 if not should_fail:
312 if not should_fail:
335 raise AssertionError("Failure not expected : '%s'" %
313 raise AssertionError("Failure not expected : '%s'" %
336 code)
314 code)
337 else:
315 else:
338 assert _ip.user_ns['code_ran']
316 assert _ip.user_ns['code_ran']
339 if should_fail:
317 if should_fail:
340 raise AssertionError("Failure expected : '%s'" % code)
318 raise AssertionError("Failure expected : '%s'" % code)
341 finally:
319 finally:
342 sys.stdin = stdin_save
320 sys.stdin = stdin_save
343
321
344
322
345 def test_cpaste():
323 def test_cpaste():
346 """Test cpaste magic"""
324 """Test cpaste magic"""
347
325
348 def run():
326 def run():
349 """Marker function: sets a flag when executed.
327 """Marker function: sets a flag when executed.
350 """
328 """
351 _ip.user_ns['code_ran'] = True
329 _ip.user_ns['code_ran'] = True
352 return 'run' # return string so '+ run()' doesn't result in success
330 return 'run' # return string so '+ run()' doesn't result in success
353
331
354 tests = {'pass': ["> > > run()",
332 tests = {'pass': ["> > > run()",
355 ">>> > run()",
333 ">>> > run()",
356 "+++ run()",
334 "+++ run()",
357 "++ run()",
335 "++ run()",
358 " >>> run()"],
336 " >>> run()"],
359
337
360 'fail': ["+ + run()",
338 'fail': ["+ + run()",
361 " ++ run()"]}
339 " ++ run()"]}
362
340
363 _ip.user_ns['run'] = run
341 _ip.user_ns['run'] = run
364
342
365 for code in tests['pass']:
343 for code in tests['pass']:
366 check_cpaste(code)
344 check_cpaste(code)
367
345
368 for code in tests['fail']:
346 for code in tests['fail']:
369 check_cpaste(code, should_fail=True)
347 check_cpaste(code, should_fail=True)
370
348
371 def test_xmode():
349 def test_xmode():
372 # Calling xmode three times should be a no-op
350 # Calling xmode three times should be a no-op
373 xmode = _ip.InteractiveTB.mode
351 xmode = _ip.InteractiveTB.mode
374 for i in range(3):
352 for i in range(3):
375 _ip.magic("xmode")
353 _ip.magic("xmode")
376 nt.assert_equal(_ip.InteractiveTB.mode, xmode)
354 nt.assert_equal(_ip.InteractiveTB.mode, xmode)
377
355
378 def doctest_who():
356 def doctest_who():
379 """doctest for %who
357 """doctest for %who
380
358
381 In [1]: %reset -f
359 In [1]: %reset -f
382
360
383 In [2]: alpha = 123
361 In [2]: alpha = 123
384
362
385 In [3]: beta = 'beta'
363 In [3]: beta = 'beta'
386
364
387 In [4]: %who int
365 In [4]: %who int
388 alpha
366 alpha
389
367
390 In [5]: %who str
368 In [5]: %who str
391 beta
369 beta
392
370
393 In [6]: %whos
371 In [6]: %whos
394 Variable Type Data/Info
372 Variable Type Data/Info
395 ----------------------------
373 ----------------------------
396 alpha int 123
374 alpha int 123
397 beta str beta
375 beta str beta
398
376
399 In [7]: %who_ls
377 In [7]: %who_ls
400 Out[7]: ['alpha', 'beta']
378 Out[7]: ['alpha', 'beta']
401 """
379 """
402
380
403 def doctest_precision():
381 def doctest_precision():
404 """doctest for %precision
382 """doctest for %precision
405
383
406 In [1]: f = get_ipython().shell.display_formatter.formatters['text/plain']
384 In [1]: f = get_ipython().shell.display_formatter.formatters['text/plain']
407
385
408 In [2]: %precision 5
386 In [2]: %precision 5
409 Out[2]: '%.5f'
387 Out[2]: '%.5f'
410
388
411 In [3]: f.float_format
389 In [3]: f.float_format
412 Out[3]: '%.5f'
390 Out[3]: '%.5f'
413
391
414 In [4]: %precision %e
392 In [4]: %precision %e
415 Out[4]: '%e'
393 Out[4]: '%e'
416
394
417 In [5]: f(3.1415927)
395 In [5]: f(3.1415927)
418 Out[5]: '3.141593e+00'
396 Out[5]: '3.141593e+00'
419 """
397 """
420
398
General Comments 0
You need to be logged in to leave comments. Login now