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