##// END OF EJS Templates
Pdb calling, pickle (under certain circumstances, connected with %run) and...
fperez -
Show More

The requested changes are too big and content was truncated. Show full diff

@@ -1,221 +1,228 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 Logger class for IPython's logging facilities.
3 Logger class for IPython's logging facilities.
4
4
5 $Id: Logger.py 974 2005-12-29 19:48:33Z fperez $
5 $Id: Logger.py 984 2005-12-31 08:40:31Z fperez $
6 """
6 """
7
7
8 #*****************************************************************************
8 #*****************************************************************************
9 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
9 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
10 # Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
10 # Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
11 #
11 #
12 # Distributed under the terms of the BSD License. The full license is in
12 # Distributed under the terms of the BSD License. The full license is in
13 # the file COPYING, distributed as part of this software.
13 # the file COPYING, distributed as part of this software.
14 #*****************************************************************************
14 #*****************************************************************************
15
15
16 #****************************************************************************
16 #****************************************************************************
17 # Modules and globals
17 # Modules and globals
18
18
19 from IPython import Release
19 from IPython import Release
20 __author__ = '%s <%s>\n%s <%s>' % \
20 __author__ = '%s <%s>\n%s <%s>' % \
21 ( Release.authors['Janko'] + Release.authors['Fernando'] )
21 ( Release.authors['Janko'] + Release.authors['Fernando'] )
22 __license__ = Release.license
22 __license__ = Release.license
23
23
24 # Python standard modules
24 # Python standard modules
25 import glob
25 import glob
26 import os
26 import os
27 import time
27 import time
28
28
29 #****************************************************************************
29 #****************************************************************************
30 # FIXME: This class isn't a mixin anymore, but it still needs attributes from
30 # FIXME: This class isn't a mixin anymore, but it still needs attributes from
31 # ipython and does input cache management. Finish cleanup later...
31 # ipython and does input cache management. Finish cleanup later...
32
32
33 class Logger(object):
33 class Logger(object):
34 """A Logfile class with different policies for file creation"""
34 """A Logfile class with different policies for file creation"""
35
35
36 def __init__(self,shell,logfname='Logger.log',loghead='',logmode='over'):
36 def __init__(self,shell,logfname='Logger.log',loghead='',logmode='over'):
37
37
38 self._i00,self._i,self._ii,self._iii = '','','',''
38 self._i00,self._i,self._ii,self._iii = '','','',''
39
39
40 # this is the full ipython instance, we need some attributes from it
40 # this is the full ipython instance, we need some attributes from it
41 # which won't exist until later. What a mess, clean up later...
41 # which won't exist until later. What a mess, clean up later...
42 self.shell = shell
42 self.shell = shell
43
43
44 self.logfname = logfname
44 self.logfname = logfname
45 self.loghead = loghead
45 self.loghead = loghead
46 self.logmode = logmode
46 self.logmode = logmode
47 self.logfile = None
47 self.logfile = None
48
48
49 # whether to also log output
49 # whether to also log output
50 self.log_output = False
50 self.log_output = False
51
51
52 # whether to put timestamps before each log entry
52 # whether to put timestamps before each log entry
53 self.timestamp = False
53 self.timestamp = False
54
54
55 # activity control flags
55 # activity control flags
56 self.log_active = False
56 self.log_active = False
57
57
58 # logmode is a validated property
58 # logmode is a validated property
59 def _set_mode(self,mode):
59 def _set_mode(self,mode):
60 if mode not in ['append','backup','global','over','rotate']:
60 if mode not in ['append','backup','global','over','rotate']:
61 raise ValueError,'invalid log mode %s given' % mode
61 raise ValueError,'invalid log mode %s given' % mode
62 self._logmode = mode
62 self._logmode = mode
63
63
64 def _get_mode(self):
64 def _get_mode(self):
65 return self._logmode
65 return self._logmode
66
66
67 logmode = property(_get_mode,_set_mode)
67 logmode = property(_get_mode,_set_mode)
68
68
69 def logstart(self,logfname=None,loghead=None,logmode=None,
69 def logstart(self,logfname=None,loghead=None,logmode=None,
70 log_output=False,timestamp=False):
70 log_output=False,timestamp=False):
71 """Generate a new log-file with a default header.
71 """Generate a new log-file with a default header.
72
72
73 Raises RuntimeError if the log has already been started"""
73 Raises RuntimeError if the log has already been started"""
74
74
75 if self.logfile is not None:
75 if self.logfile is not None:
76 raise RuntimeError('Log file is already active: %s' %
76 raise RuntimeError('Log file is already active: %s' %
77 self.logfname)
77 self.logfname)
78
78
79 self.log_active = True
79 self.log_active = True
80
80
81 # The three parameters can override constructor defaults
81 # The three parameters can override constructor defaults
82 if logfname: self.logfname = logfname
82 if logfname: self.logfname = logfname
83 if loghead: self.loghead = loghead
83 if loghead: self.loghead = loghead
84 if logmode: self.logmode = logmode
84 if logmode: self.logmode = logmode
85 self.timestamp = timestamp
85 self.timestamp = timestamp
86 self.log_output = log_output
86 self.log_output = log_output
87
87
88 # init depending on the log mode requested
88 # init depending on the log mode requested
89 isfile = os.path.isfile
89 isfile = os.path.isfile
90 logmode = self.logmode
90 logmode = self.logmode
91
91
92 if logmode == 'append':
92 if logmode == 'append':
93 self.logfile = open(self.logfname,'a')
93 self.logfile = open(self.logfname,'a')
94
94
95 elif logmode == 'backup':
95 elif logmode == 'backup':
96 if isfile(self.logfname):
96 if isfile(self.logfname):
97 backup_logname = self.logfname+'~'
97 backup_logname = self.logfname+'~'
98 # Manually remove any old backup, since os.rename may fail
98 # Manually remove any old backup, since os.rename may fail
99 # under Windows.
99 # under Windows.
100 if isfile(backup_logname):
100 if isfile(backup_logname):
101 os.remove(backup_logname)
101 os.remove(backup_logname)
102 os.rename(self.logfname,backup_logname)
102 os.rename(self.logfname,backup_logname)
103 self.logfile = open(self.logfname,'w')
103 self.logfile = open(self.logfname,'w')
104
104
105 elif logmode == 'global':
105 elif logmode == 'global':
106 self.logfname = os.path.join(self.shell.home_dir,self.logfname)
106 self.logfname = os.path.join(self.shell.home_dir,self.logfname)
107 self.logfile = open(self.logfname, 'a')
107 self.logfile = open(self.logfname, 'a')
108
108
109 elif logmode == 'over':
109 elif logmode == 'over':
110 if isfile(self.logfname):
110 if isfile(self.logfname):
111 os.remove(self.logfname)
111 os.remove(self.logfname)
112 self.logfile = open(self.logfname,'w')
112 self.logfile = open(self.logfname,'w')
113
113
114 elif logmode == 'rotate':
114 elif logmode == 'rotate':
115 if isfile(self.logfname):
115 if isfile(self.logfname):
116 if isfile(self.logfname+'.001~'):
116 if isfile(self.logfname+'.001~'):
117 old = glob.glob(self.logfname+'.*~')
117 old = glob.glob(self.logfname+'.*~')
118 old.sort()
118 old.sort()
119 old.reverse()
119 old.reverse()
120 for f in old:
120 for f in old:
121 root, ext = os.path.splitext(f)
121 root, ext = os.path.splitext(f)
122 num = int(ext[1:-1])+1
122 num = int(ext[1:-1])+1
123 os.rename(f, root+'.'+`num`.zfill(3)+'~')
123 os.rename(f, root+'.'+`num`.zfill(3)+'~')
124 os.rename(self.logfname, self.logfname+'.001~')
124 os.rename(self.logfname, self.logfname+'.001~')
125 self.logfile = open(self.logfname,'w')
125 self.logfile = open(self.logfname,'w')
126
126
127 if logmode != 'append':
127 if logmode != 'append':
128 self.logfile.write(self.loghead)
128 self.logfile.write(self.loghead)
129
129
130 self.logfile.flush()
130 self.logfile.flush()
131
131
132 def switch_log(self,val):
132 def switch_log(self,val):
133 """Switch logging on/off. val should be ONLY a boolean."""
133 """Switch logging on/off. val should be ONLY a boolean."""
134
134
135 if val not in [False,True,0,1]:
135 if val not in [False,True,0,1]:
136 raise ValueError, \
136 raise ValueError, \
137 'Call switch_log ONLY with a boolean argument, not with:',val
137 'Call switch_log ONLY with a boolean argument, not with:',val
138
138
139 label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
139 label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
140
140
141 if self.logfile is None:
141 if self.logfile is None:
142 print """
142 print """
143 Logging hasn't been started yet (use logstart for that).
143 Logging hasn't been started yet (use logstart for that).
144
144
145 %logon/%logoff are for temporarily starting and stopping logging for a logfile
145 %logon/%logoff are for temporarily starting and stopping logging for a logfile
146 which already exists. But you must first start the logging process with
146 which already exists. But you must first start the logging process with
147 %logstart (optionally giving a logfile name)."""
147 %logstart (optionally giving a logfile name)."""
148
148
149 else:
149 else:
150 if self.log_active == val:
150 if self.log_active == val:
151 print 'Logging is already',label[val]
151 print 'Logging is already',label[val]
152 else:
152 else:
153 print 'Switching logging',label[val]
153 print 'Switching logging',label[val]
154 self.log_active = not self.log_active
154 self.log_active = not self.log_active
155 self.log_active_out = self.log_active
155 self.log_active_out = self.log_active
156
156
157 def logstate(self):
157 def logstate(self):
158 """Print a status message about the logger."""
158 """Print a status message about the logger."""
159 if self.logfile is None:
159 if self.logfile is None:
160 print 'Logging has not been activated.'
160 print 'Logging has not been activated.'
161 else:
161 else:
162 state = self.log_active and 'active' or 'temporarily suspended'
162 state = self.log_active and 'active' or 'temporarily suspended'
163 print 'Filename :',self.logfname
163 print 'Filename :',self.logfname
164 print 'Mode :',self.logmode
164 print 'Mode :',self.logmode
165 print 'Output logging :',self.log_output
165 print 'Output logging :',self.log_output
166 print 'Timestamping :',self.timestamp
166 print 'Timestamping :',self.timestamp
167 print 'State :',state
167 print 'State :',state
168
168
169 def log(self, line,continuation=None):
169 def log(self, line,continuation=None):
170 """Write the line to a log and create input cache variables _i*."""
170 """Write the line to a log and create input cache variables _i*."""
171
171
172 # update the auto _i tables
172 # update the auto _i tables
173 #print '***logging line',line # dbg
173 #print '***logging line',line # dbg
174 #print '***cache_count', self.shell.outputcache.prompt_count # dbg
174 #print '***cache_count', self.shell.outputcache.prompt_count # dbg
175 input_hist = self.shell.user_ns['_ih']
175 input_hist = self.shell.user_ns['_ih']
176 if not continuation and line:
176 if not continuation and line:
177 self._iii = self._ii
177 self._iii = self._ii
178 self._ii = self._i
178 self._ii = self._i
179 self._i = self._i00
179 self._i = self._i00
180 # put back the final \n of every input line
180 # put back the final \n of every input line
181 self._i00 = line+'\n'
181 self._i00 = line+'\n'
182 #print 'Logging input:<%s>' % line # dbg
182 #print 'Logging input:<%s>' % line # dbg
183 input_hist.append(self._i00)
183 input_hist.append(self._i00)
184 #print '---[%s]' % (len(input_hist)-1,) # dbg
184
185
185 # hackish access to top-level namespace to create _i1,_i2... dynamically
186 # hackish access to top-level namespace to create _i1,_i2... dynamically
186 to_main = {'_i':self._i,'_ii':self._ii,'_iii':self._iii}
187 to_main = {'_i':self._i,'_ii':self._ii,'_iii':self._iii}
187 if self.shell.outputcache.do_full_cache:
188 if self.shell.outputcache.do_full_cache:
188 in_num = self.shell.outputcache.prompt_count
189 in_num = self.shell.outputcache.prompt_count
189 # add blank lines if the input cache fell out of sync. This can
190 # add blank lines if the input cache fell out of sync. This can
190 # happen for embedded instances which get killed via C-D and then
191 # happen for embedded instances which get killed via C-D and then
191 # get resumed.
192 # get resumed.
192 while in_num >= len(input_hist):
193 while in_num >= len(input_hist):
193 input_hist.append('\n')
194 input_hist.append('\n')
195 # but if the opposite is true (a macro can produce multiple inputs
196 # with no output display called), then bring the output counter in
197 # sync:
198 last_num = len(input_hist)-1
199 if in_num != last_num:
200 in_num = self.shell.outputcache.prompt_count = last_num
194 new_i = '_i%s' % in_num
201 new_i = '_i%s' % in_num
195 if continuation:
202 if continuation:
196 self._i00 = '%s%s\n' % (self.shell.user_ns[new_i],line)
203 self._i00 = '%s%s\n' % (self.shell.user_ns[new_i],line)
197 input_hist[in_num] = self._i00
204 input_hist[in_num] = self._i00
198 to_main[new_i] = self._i00
205 to_main[new_i] = self._i00
199 self.shell.user_ns.update(to_main)
206 self.shell.user_ns.update(to_main)
200 self.log_write(line)
207 self.log_write(line)
201
208
202 def log_write(self,data,kind='input'):
209 def log_write(self,data,kind='input'):
203 """Write data to the log file, if active"""
210 """Write data to the log file, if active"""
204
211
205 if self.log_active and data:
212 if self.log_active and data:
206 write = self.logfile.write
213 write = self.logfile.write
207 if kind=='input':
214 if kind=='input':
208 if self.timestamp:
215 if self.timestamp:
209 write(time.strftime('# %a, %d %b %Y %H:%M:%S\n',
216 write(time.strftime('# %a, %d %b %Y %H:%M:%S\n',
210 time.localtime()))
217 time.localtime()))
211 write('%s\n' % data)
218 write('%s\n' % data)
212 elif kind=='output' and self.log_output:
219 elif kind=='output' and self.log_output:
213 odata = '\n'.join(['#[Out]# %s' % s
220 odata = '\n'.join(['#[Out]# %s' % s
214 for s in data.split('\n')])
221 for s in data.split('\n')])
215 write('%s\n' % odata)
222 write('%s\n' % odata)
216 self.logfile.flush()
223 self.logfile.flush()
217
224
218 def close_log(self):
225 def close_log(self):
219 self.logfile.close()
226 self.logfile.close()
220 self.logfile = None
227 self.logfile = None
221 self.logfname = ''
228 self.logfname = ''
@@ -1,2672 +1,2677 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 975 2005-12-29 23:50:22Z fperez $"""
4 $Id: Magic.py 984 2005-12-31 08:40:31Z fperez $"""
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-2004 Fernando Perez <fperez@colorado.edu>
8 # Copyright (C) 2001-2004 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 from cStringIO import StringIO
34 from cStringIO import StringIO
35 from getopt import getopt
35 from getopt import getopt
36 from pprint import pprint, pformat
36 from pprint import pprint, pformat
37
37
38 # profile isn't bundled by default in Debian for license reasons
38 # profile isn't bundled by default in Debian for license reasons
39 try:
39 try:
40 import profile,pstats
40 import profile,pstats
41 except ImportError:
41 except ImportError:
42 profile = pstats = None
42 profile = pstats = None
43
43
44 # Homebrewed
44 # Homebrewed
45 from IPython import Debugger, OInspect, wildcard
45 from IPython import Debugger, OInspect, wildcard
46 from IPython.FakeModule import FakeModule
46 from IPython.FakeModule import FakeModule
47 from IPython.Itpl import Itpl, itpl, printpl,itplns
47 from IPython.Itpl import Itpl, itpl, printpl,itplns
48 from IPython.PyColorize import Parser
48 from IPython.PyColorize import Parser
49 from IPython.Struct import Struct
49 from IPython.Struct import Struct
50 from IPython.macro import Macro
50 from IPython.macro import Macro
51 from IPython.genutils import *
51 from IPython.genutils import *
52
52
53 #***************************************************************************
53 #***************************************************************************
54 # Utility functions
54 # Utility functions
55 def on_off(tag):
55 def on_off(tag):
56 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
56 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
57 return ['OFF','ON'][tag]
57 return ['OFF','ON'][tag]
58
58
59
59
60 #***************************************************************************
60 #***************************************************************************
61 # Main class implementing Magic functionality
61 # Main class implementing Magic functionality
62 class Magic:
62 class Magic:
63 """Magic functions for InteractiveShell.
63 """Magic functions for InteractiveShell.
64
64
65 Shell functions which can be reached as %function_name. All magic
65 Shell functions which can be reached as %function_name. All magic
66 functions should accept a string, which they can parse for their own
66 functions should accept a string, which they can parse for their own
67 needs. This can make some functions easier to type, eg `%cd ../`
67 needs. This can make some functions easier to type, eg `%cd ../`
68 vs. `%cd("../")`
68 vs. `%cd("../")`
69
69
70 ALL definitions MUST begin with the prefix magic_. The user won't need it
70 ALL definitions MUST begin with the prefix magic_. The user won't need it
71 at the command line, but it is is needed in the definition. """
71 at the command line, but it is is needed in the definition. """
72
72
73 # class globals
73 # class globals
74 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
74 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
75 'Automagic is ON, % prefix NOT needed for magic functions.']
75 'Automagic is ON, % prefix NOT needed for magic functions.']
76
76
77 #......................................................................
77 #......................................................................
78 # some utility functions
78 # some utility functions
79
79
80 def __init__(self,shell):
80 def __init__(self,shell):
81
81
82 self.options_table = {}
82 self.options_table = {}
83 if profile is None:
83 if profile is None:
84 self.magic_prun = self.profile_missing_notice
84 self.magic_prun = self.profile_missing_notice
85 self.shell = shell
85 self.shell = shell
86
86
87 def profile_missing_notice(self, *args, **kwargs):
87 def profile_missing_notice(self, *args, **kwargs):
88 error("""\
88 error("""\
89 The profile module could not be found. If you are a Debian user,
89 The profile module could not be found. If you are a Debian user,
90 it has been removed from the standard Debian package because of its non-free
90 it has been removed from the standard Debian package because of its non-free
91 license. To use profiling, please install"python2.3-profiler" from non-free.""")
91 license. To use profiling, please install"python2.3-profiler" from non-free.""")
92
92
93 def default_option(self,fn,optstr):
93 def default_option(self,fn,optstr):
94 """Make an entry in the options_table for fn, with value optstr"""
94 """Make an entry in the options_table for fn, with value optstr"""
95
95
96 if fn not in self.lsmagic():
96 if fn not in self.lsmagic():
97 error("%s is not a magic function" % fn)
97 error("%s is not a magic function" % fn)
98 self.options_table[fn] = optstr
98 self.options_table[fn] = optstr
99
99
100 def lsmagic(self):
100 def lsmagic(self):
101 """Return a list of currently available magic functions.
101 """Return a list of currently available magic functions.
102
102
103 Gives a list of the bare names after mangling (['ls','cd', ...], not
103 Gives a list of the bare names after mangling (['ls','cd', ...], not
104 ['magic_ls','magic_cd',...]"""
104 ['magic_ls','magic_cd',...]"""
105
105
106 # FIXME. This needs a cleanup, in the way the magics list is built.
106 # FIXME. This needs a cleanup, in the way the magics list is built.
107
107
108 # magics in class definition
108 # magics in class definition
109 class_magic = lambda fn: fn.startswith('magic_') and \
109 class_magic = lambda fn: fn.startswith('magic_') and \
110 callable(Magic.__dict__[fn])
110 callable(Magic.__dict__[fn])
111 # in instance namespace (run-time user additions)
111 # in instance namespace (run-time user additions)
112 inst_magic = lambda fn: fn.startswith('magic_') and \
112 inst_magic = lambda fn: fn.startswith('magic_') and \
113 callable(self.__dict__[fn])
113 callable(self.__dict__[fn])
114 # and bound magics by user (so they can access self):
114 # and bound magics by user (so they can access self):
115 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
115 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
116 callable(self.__class__.__dict__[fn])
116 callable(self.__class__.__dict__[fn])
117 magics = filter(class_magic,Magic.__dict__.keys()) + \
117 magics = filter(class_magic,Magic.__dict__.keys()) + \
118 filter(inst_magic,self.__dict__.keys()) + \
118 filter(inst_magic,self.__dict__.keys()) + \
119 filter(inst_bound_magic,self.__class__.__dict__.keys())
119 filter(inst_bound_magic,self.__class__.__dict__.keys())
120 out = []
120 out = []
121 for fn in magics:
121 for fn in magics:
122 out.append(fn.replace('magic_','',1))
122 out.append(fn.replace('magic_','',1))
123 out.sort()
123 out.sort()
124 return out
124 return out
125
125
126 def extract_input_slices(self,slices):
126 def extract_input_slices(self,slices):
127 """Return as a string a set of input history slices.
127 """Return as a string a set of input history slices.
128
128
129 The set of slices is given as a list of strings (like ['1','4:8','9'],
129 The set of slices is given as a list of strings (like ['1','4:8','9'],
130 since this function is for use by magic functions which get their
130 since this function is for use by magic functions which get their
131 arguments as strings."""
131 arguments as strings."""
132
132
133 cmds = []
133 cmds = []
134 for chunk in slices:
134 for chunk in slices:
135 if ':' in chunk:
135 if ':' in chunk:
136 ini,fin = map(int,chunk.split(':'))
136 ini,fin = map(int,chunk.split(':'))
137 else:
137 else:
138 ini = int(chunk)
138 ini = int(chunk)
139 fin = ini+1
139 fin = ini+1
140 cmds.append(self.shell.input_hist[ini:fin])
140 cmds.append(self.shell.input_hist[ini:fin])
141 return cmds
141 return cmds
142
142
143 def _ofind(self,oname):
143 def _ofind(self,oname):
144 """Find an object in the available namespaces.
144 """Find an object in the available namespaces.
145
145
146 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
146 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
147
147
148 Has special code to detect magic functions.
148 Has special code to detect magic functions.
149 """
149 """
150
150
151 oname = oname.strip()
151 oname = oname.strip()
152
152
153 # Namespaces to search in:
153 # Namespaces to search in:
154 user_ns = self.shell.user_ns
154 user_ns = self.shell.user_ns
155 internal_ns = self.shell.internal_ns
155 internal_ns = self.shell.internal_ns
156 builtin_ns = __builtin__.__dict__
156 builtin_ns = __builtin__.__dict__
157 alias_ns = self.shell.alias_table
157 alias_ns = self.shell.alias_table
158
158
159 # Put them in a list. The order is important so that we find things in
159 # Put them in a list. The order is important so that we find things in
160 # the same order that Python finds them.
160 # the same order that Python finds them.
161 namespaces = [ ('Interactive',user_ns),
161 namespaces = [ ('Interactive',user_ns),
162 ('IPython internal',internal_ns),
162 ('IPython internal',internal_ns),
163 ('Python builtin',builtin_ns),
163 ('Python builtin',builtin_ns),
164 ('Alias',alias_ns),
164 ('Alias',alias_ns),
165 ]
165 ]
166
166
167 # initialize results to 'null'
167 # initialize results to 'null'
168 found = 0; obj = None; ospace = None; ds = None;
168 found = 0; obj = None; ospace = None; ds = None;
169 ismagic = 0; isalias = 0
169 ismagic = 0; isalias = 0
170
170
171 # Look for the given name by splitting it in parts. If the head is
171 # Look for the given name by splitting it in parts. If the head is
172 # found, then we look for all the remaining parts as members, and only
172 # found, then we look for all the remaining parts as members, and only
173 # declare success if we can find them all.
173 # declare success if we can find them all.
174 oname_parts = oname.split('.')
174 oname_parts = oname.split('.')
175 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
175 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
176 for nsname,ns in namespaces:
176 for nsname,ns in namespaces:
177 try:
177 try:
178 obj = ns[oname_head]
178 obj = ns[oname_head]
179 except KeyError:
179 except KeyError:
180 continue
180 continue
181 else:
181 else:
182 for part in oname_rest:
182 for part in oname_rest:
183 try:
183 try:
184 obj = getattr(obj,part)
184 obj = getattr(obj,part)
185 except:
185 except:
186 # Blanket except b/c some badly implemented objects
186 # Blanket except b/c some badly implemented objects
187 # allow __getattr__ to raise exceptions other than
187 # allow __getattr__ to raise exceptions other than
188 # AttributeError, which then crashes IPython.
188 # AttributeError, which then crashes IPython.
189 break
189 break
190 else:
190 else:
191 # If we finish the for loop (no break), we got all members
191 # If we finish the for loop (no break), we got all members
192 found = 1
192 found = 1
193 ospace = nsname
193 ospace = nsname
194 if ns == alias_ns:
194 if ns == alias_ns:
195 isalias = 1
195 isalias = 1
196 break # namespace loop
196 break # namespace loop
197
197
198 # Try to see if it's magic
198 # Try to see if it's magic
199 if not found:
199 if not found:
200 if oname.startswith(self.shell.ESC_MAGIC):
200 if oname.startswith(self.shell.ESC_MAGIC):
201 oname = oname[1:]
201 oname = oname[1:]
202 obj = getattr(self,'magic_'+oname,None)
202 obj = getattr(self,'magic_'+oname,None)
203 if obj is not None:
203 if obj is not None:
204 found = 1
204 found = 1
205 ospace = 'IPython internal'
205 ospace = 'IPython internal'
206 ismagic = 1
206 ismagic = 1
207
207
208 # Last try: special-case some literals like '', [], {}, etc:
208 # Last try: special-case some literals like '', [], {}, etc:
209 if not found and oname_head in ["''",'""','[]','{}','()']:
209 if not found and oname_head in ["''",'""','[]','{}','()']:
210 obj = eval(oname_head)
210 obj = eval(oname_head)
211 found = 1
211 found = 1
212 ospace = 'Interactive'
212 ospace = 'Interactive'
213
213
214 return {'found':found, 'obj':obj, 'namespace':ospace,
214 return {'found':found, 'obj':obj, 'namespace':ospace,
215 'ismagic':ismagic, 'isalias':isalias}
215 'ismagic':ismagic, 'isalias':isalias}
216
216
217 def arg_err(self,func):
217 def arg_err(self,func):
218 """Print docstring if incorrect arguments were passed"""
218 """Print docstring if incorrect arguments were passed"""
219 print 'Error in arguments:'
219 print 'Error in arguments:'
220 print OInspect.getdoc(func)
220 print OInspect.getdoc(func)
221
221
222 def format_latex(self,strng):
222 def format_latex(self,strng):
223 """Format a string for latex inclusion."""
223 """Format a string for latex inclusion."""
224
224
225 # Characters that need to be escaped for latex:
225 # Characters that need to be escaped for latex:
226 escape_re = re.compile(r'(%|_|\$|#)',re.MULTILINE)
226 escape_re = re.compile(r'(%|_|\$|#)',re.MULTILINE)
227 # Magic command names as headers:
227 # Magic command names as headers:
228 cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
228 cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
229 re.MULTILINE)
229 re.MULTILINE)
230 # Magic commands
230 # Magic commands
231 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
231 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
232 re.MULTILINE)
232 re.MULTILINE)
233 # Paragraph continue
233 # Paragraph continue
234 par_re = re.compile(r'\\$',re.MULTILINE)
234 par_re = re.compile(r'\\$',re.MULTILINE)
235
235
236 # The "\n" symbol
236 # The "\n" symbol
237 newline_re = re.compile(r'\\n')
237 newline_re = re.compile(r'\\n')
238
238
239 # Now build the string for output:
239 # Now build the string for output:
240 strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
240 strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
241 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
241 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
242 strng = par_re.sub(r'\\\\',strng)
242 strng = par_re.sub(r'\\\\',strng)
243 strng = escape_re.sub(r'\\\1',strng)
243 strng = escape_re.sub(r'\\\1',strng)
244 strng = newline_re.sub(r'\\textbackslash{}n',strng)
244 strng = newline_re.sub(r'\\textbackslash{}n',strng)
245 return strng
245 return strng
246
246
247 def format_screen(self,strng):
247 def format_screen(self,strng):
248 """Format a string for screen printing.
248 """Format a string for screen printing.
249
249
250 This removes some latex-type format codes."""
250 This removes some latex-type format codes."""
251 # Paragraph continue
251 # Paragraph continue
252 par_re = re.compile(r'\\$',re.MULTILINE)
252 par_re = re.compile(r'\\$',re.MULTILINE)
253 strng = par_re.sub('',strng)
253 strng = par_re.sub('',strng)
254 return strng
254 return strng
255
255
256 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
256 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
257 """Parse options passed to an argument string.
257 """Parse options passed to an argument string.
258
258
259 The interface is similar to that of getopt(), but it returns back a
259 The interface is similar to that of getopt(), but it returns back a
260 Struct with the options as keys and the stripped argument string still
260 Struct with the options as keys and the stripped argument string still
261 as a string.
261 as a string.
262
262
263 arg_str is quoted as a true sys.argv vector by using shlex.split.
263 arg_str is quoted as a true sys.argv vector by using shlex.split.
264 This allows us to easily expand variables, glob files, quote
264 This allows us to easily expand variables, glob files, quote
265 arguments, etc.
265 arguments, etc.
266
266
267 Options:
267 Options:
268 -mode: default 'string'. If given as 'list', the argument string is
268 -mode: default 'string'. If given as 'list', the argument string is
269 returned as a list (split on whitespace) instead of a string.
269 returned as a list (split on whitespace) instead of a string.
270
270
271 -list_all: put all option values in lists. Normally only options
271 -list_all: put all option values in lists. Normally only options
272 appearing more than once are put in a list."""
272 appearing more than once are put in a list."""
273
273
274 # inject default options at the beginning of the input line
274 # inject default options at the beginning of the input line
275 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
275 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
276 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
276 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
277
277
278 mode = kw.get('mode','string')
278 mode = kw.get('mode','string')
279 if mode not in ['string','list']:
279 if mode not in ['string','list']:
280 raise ValueError,'incorrect mode given: %s' % mode
280 raise ValueError,'incorrect mode given: %s' % mode
281 # Get options
281 # Get options
282 list_all = kw.get('list_all',0)
282 list_all = kw.get('list_all',0)
283
283
284 # Check if we have more than one argument to warrant extra processing:
284 # Check if we have more than one argument to warrant extra processing:
285 odict = {} # Dictionary with options
285 odict = {} # Dictionary with options
286 args = arg_str.split()
286 args = arg_str.split()
287 if len(args) >= 1:
287 if len(args) >= 1:
288 # If the list of inputs only has 0 or 1 thing in it, there's no
288 # If the list of inputs only has 0 or 1 thing in it, there's no
289 # need to look for options
289 # need to look for options
290 argv = shlex_split(arg_str)
290 argv = shlex_split(arg_str)
291 # Do regular option processing
291 # Do regular option processing
292 opts,args = getopt(argv,opt_str,*long_opts)
292 opts,args = getopt(argv,opt_str,*long_opts)
293 for o,a in opts:
293 for o,a in opts:
294 if o.startswith('--'):
294 if o.startswith('--'):
295 o = o[2:]
295 o = o[2:]
296 else:
296 else:
297 o = o[1:]
297 o = o[1:]
298 try:
298 try:
299 odict[o].append(a)
299 odict[o].append(a)
300 except AttributeError:
300 except AttributeError:
301 odict[o] = [odict[o],a]
301 odict[o] = [odict[o],a]
302 except KeyError:
302 except KeyError:
303 if list_all:
303 if list_all:
304 odict[o] = [a]
304 odict[o] = [a]
305 else:
305 else:
306 odict[o] = a
306 odict[o] = a
307
307
308 # Prepare opts,args for return
308 # Prepare opts,args for return
309 opts = Struct(odict)
309 opts = Struct(odict)
310 if mode == 'string':
310 if mode == 'string':
311 args = ' '.join(args)
311 args = ' '.join(args)
312
312
313 return opts,args
313 return opts,args
314
314
315 #......................................................................
315 #......................................................................
316 # And now the actual magic functions
316 # And now the actual magic functions
317
317
318 # Functions for IPython shell work (vars,funcs, config, etc)
318 # Functions for IPython shell work (vars,funcs, config, etc)
319 def magic_lsmagic(self, parameter_s = ''):
319 def magic_lsmagic(self, parameter_s = ''):
320 """List currently available magic functions."""
320 """List currently available magic functions."""
321 mesc = self.shell.ESC_MAGIC
321 mesc = self.shell.ESC_MAGIC
322 print 'Available magic functions:\n'+mesc+\
322 print 'Available magic functions:\n'+mesc+\
323 (' '+mesc).join(self.lsmagic())
323 (' '+mesc).join(self.lsmagic())
324 print '\n' + Magic.auto_status[self.shell.rc.automagic]
324 print '\n' + Magic.auto_status[self.shell.rc.automagic]
325 return None
325 return None
326
326
327 def magic_magic(self, parameter_s = ''):
327 def magic_magic(self, parameter_s = ''):
328 """Print information about the magic function system."""
328 """Print information about the magic function system."""
329
329
330 mode = ''
330 mode = ''
331 try:
331 try:
332 if parameter_s.split()[0] == '-latex':
332 if parameter_s.split()[0] == '-latex':
333 mode = 'latex'
333 mode = 'latex'
334 except:
334 except:
335 pass
335 pass
336
336
337 magic_docs = []
337 magic_docs = []
338 for fname in self.lsmagic():
338 for fname in self.lsmagic():
339 mname = 'magic_' + fname
339 mname = 'magic_' + fname
340 for space in (Magic,self,self.__class__):
340 for space in (Magic,self,self.__class__):
341 try:
341 try:
342 fn = space.__dict__[mname]
342 fn = space.__dict__[mname]
343 except KeyError:
343 except KeyError:
344 pass
344 pass
345 else:
345 else:
346 break
346 break
347 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
347 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
348 fname,fn.__doc__))
348 fname,fn.__doc__))
349 magic_docs = ''.join(magic_docs)
349 magic_docs = ''.join(magic_docs)
350
350
351 if mode == 'latex':
351 if mode == 'latex':
352 print self.format_latex(magic_docs)
352 print self.format_latex(magic_docs)
353 return
353 return
354 else:
354 else:
355 magic_docs = self.format_screen(magic_docs)
355 magic_docs = self.format_screen(magic_docs)
356
356
357 outmsg = """
357 outmsg = """
358 IPython's 'magic' functions
358 IPython's 'magic' functions
359 ===========================
359 ===========================
360
360
361 The magic function system provides a series of functions which allow you to
361 The magic function system provides a series of functions which allow you to
362 control the behavior of IPython itself, plus a lot of system-type
362 control the behavior of IPython itself, plus a lot of system-type
363 features. All these functions are prefixed with a % character, but parameters
363 features. All these functions are prefixed with a % character, but parameters
364 are given without parentheses or quotes.
364 are given without parentheses or quotes.
365
365
366 NOTE: If you have 'automagic' enabled (via the command line option or with the
366 NOTE: If you have 'automagic' enabled (via the command line option or with the
367 %automagic function), you don't need to type in the % explicitly. By default,
367 %automagic function), you don't need to type in the % explicitly. By default,
368 IPython ships with automagic on, so you should only rarely need the % escape.
368 IPython ships with automagic on, so you should only rarely need the % escape.
369
369
370 Example: typing '%cd mydir' (without the quotes) changes you working directory
370 Example: typing '%cd mydir' (without the quotes) changes you working directory
371 to 'mydir', if it exists.
371 to 'mydir', if it exists.
372
372
373 You can define your own magic functions to extend the system. See the supplied
373 You can define your own magic functions to extend the system. See the supplied
374 ipythonrc and example-magic.py files for details (in your ipython
374 ipythonrc and example-magic.py files for details (in your ipython
375 configuration directory, typically $HOME/.ipython/).
375 configuration directory, typically $HOME/.ipython/).
376
376
377 You can also define your own aliased names for magic functions. In your
377 You can also define your own aliased names for magic functions. In your
378 ipythonrc file, placing a line like:
378 ipythonrc file, placing a line like:
379
379
380 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
380 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
381
381
382 will define %pf as a new name for %profile.
382 will define %pf as a new name for %profile.
383
383
384 You can also call magics in code using the ipmagic() function, which IPython
384 You can also call magics in code using the ipmagic() function, which IPython
385 automatically adds to the builtin namespace. Type 'ipmagic?' for details.
385 automatically adds to the builtin namespace. Type 'ipmagic?' for details.
386
386
387 For a list of the available magic functions, use %lsmagic. For a description
387 For a list of the available magic functions, use %lsmagic. For a description
388 of any of them, type %magic_name?, e.g. '%cd?'.
388 of any of them, type %magic_name?, e.g. '%cd?'.
389
389
390 Currently the magic system has the following functions:\n"""
390 Currently the magic system has the following functions:\n"""
391
391
392 mesc = self.shell.ESC_MAGIC
392 mesc = self.shell.ESC_MAGIC
393 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
393 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
394 "\n\n%s%s\n\n%s" % (outmsg,
394 "\n\n%s%s\n\n%s" % (outmsg,
395 magic_docs,mesc,mesc,
395 magic_docs,mesc,mesc,
396 (' '+mesc).join(self.lsmagic()),
396 (' '+mesc).join(self.lsmagic()),
397 Magic.auto_status[self.shell.rc.automagic] ) )
397 Magic.auto_status[self.shell.rc.automagic] ) )
398
398
399 page(outmsg,screen_lines=self.shell.rc.screen_length)
399 page(outmsg,screen_lines=self.shell.rc.screen_length)
400
400
401 def magic_automagic(self, parameter_s = ''):
401 def magic_automagic(self, parameter_s = ''):
402 """Make magic functions callable without having to type the initial %.
402 """Make magic functions callable without having to type the initial %.
403
403
404 Toggles on/off (when off, you must call it as %automagic, of
404 Toggles on/off (when off, you must call it as %automagic, of
405 course). Note that magic functions have lowest priority, so if there's
405 course). Note that magic functions have lowest priority, so if there's
406 a variable whose name collides with that of a magic fn, automagic
406 a variable whose name collides with that of a magic fn, automagic
407 won't work for that function (you get the variable instead). However,
407 won't work for that function (you get the variable instead). However,
408 if you delete the variable (del var), the previously shadowed magic
408 if you delete the variable (del var), the previously shadowed magic
409 function becomes visible to automagic again."""
409 function becomes visible to automagic again."""
410
410
411 rc = self.shell.rc
411 rc = self.shell.rc
412 rc.automagic = not rc.automagic
412 rc.automagic = not rc.automagic
413 print '\n' + Magic.auto_status[rc.automagic]
413 print '\n' + Magic.auto_status[rc.automagic]
414
414
415 def magic_autocall(self, parameter_s = ''):
415 def magic_autocall(self, parameter_s = ''):
416 """Make functions callable without having to type parentheses.
416 """Make functions callable without having to type parentheses.
417
417
418 This toggles the autocall command line option on and off."""
418 This toggles the autocall command line option on and off."""
419
419
420 rc = self.shell.rc
420 rc = self.shell.rc
421 rc.autocall = not rc.autocall
421 rc.autocall = not rc.autocall
422 print "Automatic calling is:",['OFF','ON'][rc.autocall]
422 print "Automatic calling is:",['OFF','ON'][rc.autocall]
423
423
424 def magic_autoindent(self, parameter_s = ''):
424 def magic_autoindent(self, parameter_s = ''):
425 """Toggle autoindent on/off (if available)."""
425 """Toggle autoindent on/off (if available)."""
426
426
427 self.shell.set_autoindent()
427 self.shell.set_autoindent()
428 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
428 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
429
429
430 def magic_system_verbose(self, parameter_s = ''):
430 def magic_system_verbose(self, parameter_s = ''):
431 """Toggle verbose printing of system calls on/off."""
431 """Toggle verbose printing of system calls on/off."""
432
432
433 self.shell.rc_set_toggle('system_verbose')
433 self.shell.rc_set_toggle('system_verbose')
434 print "System verbose printing is:",\
434 print "System verbose printing is:",\
435 ['OFF','ON'][self.shell.rc.system_verbose]
435 ['OFF','ON'][self.shell.rc.system_verbose]
436
436
437 def magic_history(self, parameter_s = ''):
437 def magic_history(self, parameter_s = ''):
438 """Print input history (_i<n> variables), with most recent last.
438 """Print input history (_i<n> variables), with most recent last.
439
439
440 %history [-n] -> print at most 40 inputs (some may be multi-line)\\
440 %history [-n] -> print at most 40 inputs (some may be multi-line)\\
441 %history [-n] n -> print at most n inputs\\
441 %history [-n] n -> print at most n inputs\\
442 %history [-n] n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
442 %history [-n] n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
443
443
444 Each input's number <n> is shown, and is accessible as the
444 Each input's number <n> is shown, and is accessible as the
445 automatically generated variable _i<n>. Multi-line statements are
445 automatically generated variable _i<n>. Multi-line statements are
446 printed starting at a new line for easy copy/paste.
446 printed starting at a new line for easy copy/paste.
447
447
448 If option -n is used, input numbers are not printed. This is useful if
448 If option -n is used, input numbers are not printed. This is useful if
449 you want to get a printout of many lines which can be directly pasted
449 you want to get a printout of many lines which can be directly pasted
450 into a text editor.
450 into a text editor.
451
451
452 This feature is only available if numbered prompts are in use."""
452 This feature is only available if numbered prompts are in use."""
453
453
454 if not self.shell.outputcache.do_full_cache:
454 shell = self.shell
455 if not shell.outputcache.do_full_cache:
455 print 'This feature is only available if numbered prompts are in use.'
456 print 'This feature is only available if numbered prompts are in use.'
456 return
457 return
457 opts,args = self.parse_options(parameter_s,'n',mode='list')
458 opts,args = self.parse_options(parameter_s,'n',mode='list')
458
459
460 input_hist = shell.input_hist
459 default_length = 40
461 default_length = 40
460 if len(args) == 0:
462 if len(args) == 0:
461 final = self.shell.outputcache.prompt_count
463 final = len(input_hist)
462 init = max(1,final-default_length)
464 init = max(1,final-default_length)
463 elif len(args) == 1:
465 elif len(args) == 1:
464 final = self.shell.outputcache.prompt_count
466 final = len(input_hist)
465 init = max(1,final-int(args[0]))
467 init = max(1,final-int(args[0]))
466 elif len(args) == 2:
468 elif len(args) == 2:
467 init,final = map(int,args)
469 init,final = map(int,args)
468 else:
470 else:
469 warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
471 warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
470 print self.magic_hist.__doc__
472 print self.magic_hist.__doc__
471 return
473 return
472 width = len(str(final))
474 width = len(str(final))
473 line_sep = ['','\n']
475 line_sep = ['','\n']
474 input_hist = self.shell.input_hist
475 print_nums = not opts.has_key('n')
476 print_nums = not opts.has_key('n')
476 for in_num in range(init,final):
477 for in_num in range(init,final):
477 inline = input_hist[in_num]
478 inline = input_hist[in_num]
478 multiline = inline.count('\n') > 1
479 multiline = int(inline.count('\n') > 1)
479 if print_nums:
480 if print_nums:
480 print str(in_num).ljust(width)+':'+ line_sep[multiline],
481 print '%s:%s' % (str(in_num).ljust(width),line_sep[multiline]),
481 if inline.startswith('#'+self.shell.ESC_MAGIC) or \
482 print inline,
482 inline.startswith('#!'):
483 print inline[1:],
484 else:
485 print inline,
486
483
487 def magic_hist(self, parameter_s=''):
484 def magic_hist(self, parameter_s=''):
488 """Alternate name for %history."""
485 """Alternate name for %history."""
489 return self.magic_history(parameter_s)
486 return self.magic_history(parameter_s)
490
487
491 def magic_p(self, parameter_s=''):
488 def magic_p(self, parameter_s=''):
492 """Just a short alias for Python's 'print'."""
489 """Just a short alias for Python's 'print'."""
493 exec 'print ' + parameter_s in self.shell.user_ns
490 exec 'print ' + parameter_s in self.shell.user_ns
494
491
495 def magic_r(self, parameter_s=''):
492 def magic_r(self, parameter_s=''):
496 """Repeat previous input.
493 """Repeat previous input.
497
494
498 If given an argument, repeats the previous command which starts with
495 If given an argument, repeats the previous command which starts with
499 the same string, otherwise it just repeats the previous input.
496 the same string, otherwise it just repeats the previous input.
500
497
501 Shell escaped commands (with ! as first character) are not recognized
498 Shell escaped commands (with ! as first character) are not recognized
502 by this system, only pure python code and magic commands.
499 by this system, only pure python code and magic commands.
503 """
500 """
504
501
505 start = parameter_s.strip()
502 start = parameter_s.strip()
506 esc_magic = self.shell.ESC_MAGIC
503 esc_magic = self.shell.ESC_MAGIC
507 # Identify magic commands even if automagic is on (which means
504 # Identify magic commands even if automagic is on (which means
508 # the in-memory version is different from that typed by the user).
505 # the in-memory version is different from that typed by the user).
509 if self.shell.rc.automagic:
506 if self.shell.rc.automagic:
510 start_magic = esc_magic+start
507 start_magic = esc_magic+start
511 else:
508 else:
512 start_magic = start
509 start_magic = start
513 # Look through the input history in reverse
510 # Look through the input history in reverse
514 for n in range(len(self.shell.input_hist)-2,0,-1):
511 for n in range(len(self.shell.input_hist)-2,0,-1):
515 input = self.shell.input_hist[n]
512 input = self.shell.input_hist[n]
516 # skip plain 'r' lines so we don't recurse to infinity
513 # skip plain 'r' lines so we don't recurse to infinity
517 if input != 'ipmagic("r")\n' and \
514 if input != 'ipmagic("r")\n' and \
518 (input.startswith(start) or input.startswith(start_magic)):
515 (input.startswith(start) or input.startswith(start_magic)):
519 #print 'match',`input` # dbg
516 #print 'match',`input` # dbg
520 print 'Executing:',input,
517 print 'Executing:',input,
521 self.shell.runlines(input)
518 self.shell.runlines(input)
522 return
519 return
523 print 'No previous input matching `%s` found.' % start
520 print 'No previous input matching `%s` found.' % start
524
521
525 def magic_page(self, parameter_s=''):
522 def magic_page(self, parameter_s=''):
526 """Pretty print the object and display it through a pager.
523 """Pretty print the object and display it through a pager.
527
524
528 If no parameter is given, use _ (last output)."""
525 If no parameter is given, use _ (last output)."""
529 # After a function contributed by Olivier Aubert, slightly modified.
526 # After a function contributed by Olivier Aubert, slightly modified.
530
527
531 oname = parameter_s and parameter_s or '_'
528 oname = parameter_s and parameter_s or '_'
532 info = self._ofind(oname)
529 info = self._ofind(oname)
533 if info['found']:
530 if info['found']:
534 page(pformat(info['obj']))
531 page(pformat(info['obj']))
535 else:
532 else:
536 print 'Object `%s` not found' % oname
533 print 'Object `%s` not found' % oname
537
534
538 def magic_profile(self, parameter_s=''):
535 def magic_profile(self, parameter_s=''):
539 """Print your currently active IPyhton profile."""
536 """Print your currently active IPyhton profile."""
540 if self.shell.rc.profile:
537 if self.shell.rc.profile:
541 printpl('Current IPython profile: $self.shell.rc.profile.')
538 printpl('Current IPython profile: $self.shell.rc.profile.')
542 else:
539 else:
543 print 'No profile active.'
540 print 'No profile active.'
544
541
545 def _inspect(self,meth,oname,**kw):
542 def _inspect(self,meth,oname,**kw):
546 """Generic interface to the inspector system.
543 """Generic interface to the inspector system.
547
544
548 This function is meant to be called by pdef, pdoc & friends."""
545 This function is meant to be called by pdef, pdoc & friends."""
549
546
550 oname = oname.strip()
547 oname = oname.strip()
551 info = Struct(self._ofind(oname))
548 info = Struct(self._ofind(oname))
552 if info.found:
549 if info.found:
553 pmethod = getattr(self.shell.inspector,meth)
550 pmethod = getattr(self.shell.inspector,meth)
554 formatter = info.ismagic and self.format_screen or None
551 formatter = info.ismagic and self.format_screen or None
555 if meth == 'pdoc':
552 if meth == 'pdoc':
556 pmethod(info.obj,oname,formatter)
553 pmethod(info.obj,oname,formatter)
557 elif meth == 'pinfo':
554 elif meth == 'pinfo':
558 pmethod(info.obj,oname,formatter,info,**kw)
555 pmethod(info.obj,oname,formatter,info,**kw)
559 else:
556 else:
560 pmethod(info.obj,oname)
557 pmethod(info.obj,oname)
561 else:
558 else:
562 print 'Object `%s` not found.' % oname
559 print 'Object `%s` not found.' % oname
563 return 'not found' # so callers can take other action
560 return 'not found' # so callers can take other action
564
561
565 def magic_pdef(self, parameter_s=''):
562 def magic_pdef(self, parameter_s=''):
566 """Print the definition header for any callable object.
563 """Print the definition header for any callable object.
567
564
568 If the object is a class, print the constructor information."""
565 If the object is a class, print the constructor information."""
569 self._inspect('pdef',parameter_s)
566 self._inspect('pdef',parameter_s)
570
567
571 def magic_pdoc(self, parameter_s=''):
568 def magic_pdoc(self, parameter_s=''):
572 """Print the docstring for an object.
569 """Print the docstring for an object.
573
570
574 If the given object is a class, it will print both the class and the
571 If the given object is a class, it will print both the class and the
575 constructor docstrings."""
572 constructor docstrings."""
576 self._inspect('pdoc',parameter_s)
573 self._inspect('pdoc',parameter_s)
577
574
578 def magic_psource(self, parameter_s=''):
575 def magic_psource(self, parameter_s=''):
579 """Print (or run through pager) the source code for an object."""
576 """Print (or run through pager) the source code for an object."""
580 self._inspect('psource',parameter_s)
577 self._inspect('psource',parameter_s)
581
578
582 def magic_pfile(self, parameter_s=''):
579 def magic_pfile(self, parameter_s=''):
583 """Print (or run through pager) the file where an object is defined.
580 """Print (or run through pager) the file where an object is defined.
584
581
585 The file opens at the line where the object definition begins. IPython
582 The file opens at the line where the object definition begins. IPython
586 will honor the environment variable PAGER if set, and otherwise will
583 will honor the environment variable PAGER if set, and otherwise will
587 do its best to print the file in a convenient form.
584 do its best to print the file in a convenient form.
588
585
589 If the given argument is not an object currently defined, IPython will
586 If the given argument is not an object currently defined, IPython will
590 try to interpret it as a filename (automatically adding a .py extension
587 try to interpret it as a filename (automatically adding a .py extension
591 if needed). You can thus use %pfile as a syntax highlighting code
588 if needed). You can thus use %pfile as a syntax highlighting code
592 viewer."""
589 viewer."""
593
590
594 # first interpret argument as an object name
591 # first interpret argument as an object name
595 out = self._inspect('pfile',parameter_s)
592 out = self._inspect('pfile',parameter_s)
596 # if not, try the input as a filename
593 # if not, try the input as a filename
597 if out == 'not found':
594 if out == 'not found':
598 try:
595 try:
599 filename = get_py_filename(parameter_s)
596 filename = get_py_filename(parameter_s)
600 except IOError,msg:
597 except IOError,msg:
601 print msg
598 print msg
602 return
599 return
603 page(self.shell.inspector.format(file(filename).read()))
600 page(self.shell.inspector.format(file(filename).read()))
604
601
605 def magic_pinfo(self, parameter_s=''):
602 def magic_pinfo(self, parameter_s=''):
606 """Provide detailed information about an object.
603 """Provide detailed information about an object.
607
604
608 '%pinfo object' is just a synonym for object? or ?object."""
605 '%pinfo object' is just a synonym for object? or ?object."""
609
606
610 #print 'pinfo par: <%s>' % parameter_s # dbg
607 #print 'pinfo par: <%s>' % parameter_s # dbg
611
608
612 # detail_level: 0 -> obj? , 1 -> obj??
609 # detail_level: 0 -> obj? , 1 -> obj??
613 detail_level = 0
610 detail_level = 0
614 # We need to detect if we got called as 'pinfo pinfo foo', which can
611 # We need to detect if we got called as 'pinfo pinfo foo', which can
615 # happen if the user types 'pinfo foo?' at the cmd line.
612 # happen if the user types 'pinfo foo?' at the cmd line.
616 pinfo,qmark1,oname,qmark2 = \
613 pinfo,qmark1,oname,qmark2 = \
617 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
614 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
618 if pinfo or qmark1 or qmark2:
615 if pinfo or qmark1 or qmark2:
619 detail_level = 1
616 detail_level = 1
620 if "*" in oname:
617 if "*" in oname:
621 self.magic_psearch(oname)
618 self.magic_psearch(oname)
622 else:
619 else:
623 self._inspect('pinfo',oname,detail_level=detail_level)
620 self._inspect('pinfo',oname,detail_level=detail_level)
624
621
625 def magic_psearch(self, parameter_s=''):
622 def magic_psearch(self, parameter_s=''):
626 """Search for object in namespaces by wildcard.
623 """Search for object in namespaces by wildcard.
627
624
628 %psearch [options] PATTERN [OBJECT TYPE]
625 %psearch [options] PATTERN [OBJECT TYPE]
629
626
630 Note: ? can be used as a synonym for %psearch, at the beginning or at
627 Note: ? can be used as a synonym for %psearch, at the beginning or at
631 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
628 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
632 rest of the command line must be unchanged (options come first), so
629 rest of the command line must be unchanged (options come first), so
633 for example the following forms are equivalent
630 for example the following forms are equivalent
634
631
635 %psearch -i a* function
632 %psearch -i a* function
636 -i a* function?
633 -i a* function?
637 ?-i a* function
634 ?-i a* function
638
635
639 Arguments:
636 Arguments:
640
637
641 PATTERN
638 PATTERN
642
639
643 where PATTERN is a string containing * as a wildcard similar to its
640 where PATTERN is a string containing * as a wildcard similar to its
644 use in a shell. The pattern is matched in all namespaces on the
641 use in a shell. The pattern is matched in all namespaces on the
645 search path. By default objects starting with a single _ are not
642 search path. By default objects starting with a single _ are not
646 matched, many IPython generated objects have a single
643 matched, many IPython generated objects have a single
647 underscore. The default is case insensitive matching. Matching is
644 underscore. The default is case insensitive matching. Matching is
648 also done on the attributes of objects and not only on the objects
645 also done on the attributes of objects and not only on the objects
649 in a module.
646 in a module.
650
647
651 [OBJECT TYPE]
648 [OBJECT TYPE]
652
649
653 Is the name of a python type from the types module. The name is
650 Is the name of a python type from the types module. The name is
654 given in lowercase without the ending type, ex. StringType is
651 given in lowercase without the ending type, ex. StringType is
655 written string. By adding a type here only objects matching the
652 written string. By adding a type here only objects matching the
656 given type are matched. Using all here makes the pattern match all
653 given type are matched. Using all here makes the pattern match all
657 types (this is the default).
654 types (this is the default).
658
655
659 Options:
656 Options:
660
657
661 -a: makes the pattern match even objects whose names start with a
658 -a: makes the pattern match even objects whose names start with a
662 single underscore. These names are normally ommitted from the
659 single underscore. These names are normally ommitted from the
663 search.
660 search.
664
661
665 -i/-c: make the pattern case insensitive/sensitive. If neither of
662 -i/-c: make the pattern case insensitive/sensitive. If neither of
666 these options is given, the default is read from your ipythonrc
663 these options is given, the default is read from your ipythonrc
667 file. The option name which sets this value is
664 file. The option name which sets this value is
668 'wildcards_case_sensitive'. If this option is not specified in your
665 'wildcards_case_sensitive'. If this option is not specified in your
669 ipythonrc file, IPython's internal default is to do a case sensitive
666 ipythonrc file, IPython's internal default is to do a case sensitive
670 search.
667 search.
671
668
672 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
669 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
673 specifiy can be searched in any of the following namespaces:
670 specifiy can be searched in any of the following namespaces:
674 'builtin', 'user', 'user_global','internal', 'alias', where
671 'builtin', 'user', 'user_global','internal', 'alias', where
675 'builtin' and 'user' are the search defaults. Note that you should
672 'builtin' and 'user' are the search defaults. Note that you should
676 not use quotes when specifying namespaces.
673 not use quotes when specifying namespaces.
677
674
678 'Builtin' contains the python module builtin, 'user' contains all
675 'Builtin' contains the python module builtin, 'user' contains all
679 user data, 'alias' only contain the shell aliases and no python
676 user data, 'alias' only contain the shell aliases and no python
680 objects, 'internal' contains objects used by IPython. The
677 objects, 'internal' contains objects used by IPython. The
681 'user_global' namespace is only used by embedded IPython instances,
678 'user_global' namespace is only used by embedded IPython instances,
682 and it contains module-level globals. You can add namespaces to the
679 and it contains module-level globals. You can add namespaces to the
683 search with -s or exclude them with -e (these options can be given
680 search with -s or exclude them with -e (these options can be given
684 more than once).
681 more than once).
685
682
686 Examples:
683 Examples:
687
684
688 %psearch a* -> objects beginning with an a
685 %psearch a* -> objects beginning with an a
689 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
686 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
690 %psearch a* function -> all functions beginning with an a
687 %psearch a* function -> all functions beginning with an a
691 %psearch re.e* -> objects beginning with an e in module re
688 %psearch re.e* -> objects beginning with an e in module re
692 %psearch r*.e* -> objects that start with e in modules starting in r
689 %psearch r*.e* -> objects that start with e in modules starting in r
693 %psearch r*.* string -> all strings in modules beginning with r
690 %psearch r*.* string -> all strings in modules beginning with r
694
691
695 Case sensitve search:
692 Case sensitve search:
696
693
697 %psearch -c a* list all object beginning with lower case a
694 %psearch -c a* list all object beginning with lower case a
698
695
699 Show objects beginning with a single _:
696 Show objects beginning with a single _:
700
697
701 %psearch -a _* list objects beginning with a single underscore"""
698 %psearch -a _* list objects beginning with a single underscore"""
702
699
703 # default namespaces to be searched
700 # default namespaces to be searched
704 def_search = ['user','builtin']
701 def_search = ['user','builtin']
705
702
706 # Process options/args
703 # Process options/args
707 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
704 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
708 opt = opts.get
705 opt = opts.get
709 shell = self.shell
706 shell = self.shell
710 psearch = shell.inspector.psearch
707 psearch = shell.inspector.psearch
711
708
712 # select case options
709 # select case options
713 if opts.has_key('i'):
710 if opts.has_key('i'):
714 ignore_case = True
711 ignore_case = True
715 elif opts.has_key('c'):
712 elif opts.has_key('c'):
716 ignore_case = False
713 ignore_case = False
717 else:
714 else:
718 ignore_case = not shell.rc.wildcards_case_sensitive
715 ignore_case = not shell.rc.wildcards_case_sensitive
719
716
720 # Build list of namespaces to search from user options
717 # Build list of namespaces to search from user options
721 def_search.extend(opt('s',[]))
718 def_search.extend(opt('s',[]))
722 ns_exclude = ns_exclude=opt('e',[])
719 ns_exclude = ns_exclude=opt('e',[])
723 ns_search = [nm for nm in def_search if nm not in ns_exclude]
720 ns_search = [nm for nm in def_search if nm not in ns_exclude]
724
721
725 # Call the actual search
722 # Call the actual search
726 try:
723 try:
727 psearch(args,shell.ns_table,ns_search,
724 psearch(args,shell.ns_table,ns_search,
728 show_all=opt('a'),ignore_case=ignore_case)
725 show_all=opt('a'),ignore_case=ignore_case)
729 except:
726 except:
730 shell.showtraceback()
727 shell.showtraceback()
731
728
732 def magic_who_ls(self, parameter_s=''):
729 def magic_who_ls(self, parameter_s=''):
733 """Return a sorted list of all interactive variables.
730 """Return a sorted list of all interactive variables.
734
731
735 If arguments are given, only variables of types matching these
732 If arguments are given, only variables of types matching these
736 arguments are returned."""
733 arguments are returned."""
737
734
738 user_ns = self.shell.user_ns
735 user_ns = self.shell.user_ns
739 out = []
736 out = []
740 typelist = parameter_s.split()
737 typelist = parameter_s.split()
741 for i in self.shell.user_ns.keys():
738 for i in self.shell.user_ns.keys():
742 if not (i.startswith('_') or i.startswith('_i')) \
739 if not (i.startswith('_') or i.startswith('_i')) \
743 and not (self.shell.internal_ns.has_key(i) or
740 and not (self.shell.internal_ns.has_key(i) or
744 self.shell.user_config_ns.has_key(i)):
741 self.shell.user_config_ns.has_key(i)):
745 if typelist:
742 if typelist:
746 if type(user_ns[i]).__name__ in typelist:
743 if type(user_ns[i]).__name__ in typelist:
747 out.append(i)
744 out.append(i)
748 else:
745 else:
749 out.append(i)
746 out.append(i)
750 out.sort()
747 out.sort()
751 return out
748 return out
752
749
753 def magic_who(self, parameter_s=''):
750 def magic_who(self, parameter_s=''):
754 """Print all interactive variables, with some minimal formatting.
751 """Print all interactive variables, with some minimal formatting.
755
752
756 If any arguments are given, only variables whose type matches one of
753 If any arguments are given, only variables whose type matches one of
757 these are printed. For example:
754 these are printed. For example:
758
755
759 %who function str
756 %who function str
760
757
761 will only list functions and strings, excluding all other types of
758 will only list functions and strings, excluding all other types of
762 variables. To find the proper type names, simply use type(var) at a
759 variables. To find the proper type names, simply use type(var) at a
763 command line to see how python prints type names. For example:
760 command line to see how python prints type names. For example:
764
761
765 In [1]: type('hello')\\
762 In [1]: type('hello')\\
766 Out[1]: <type 'str'>
763 Out[1]: <type 'str'>
767
764
768 indicates that the type name for strings is 'str'.
765 indicates that the type name for strings is 'str'.
769
766
770 %who always excludes executed names loaded through your configuration
767 %who always excludes executed names loaded through your configuration
771 file and things which are internal to IPython.
768 file and things which are internal to IPython.
772
769
773 This is deliberate, as typically you may load many modules and the
770 This is deliberate, as typically you may load many modules and the
774 purpose of %who is to show you only what you've manually defined."""
771 purpose of %who is to show you only what you've manually defined."""
775
772
776 varlist = self.magic_who_ls(parameter_s)
773 varlist = self.magic_who_ls(parameter_s)
777 if not varlist:
774 if not varlist:
778 print 'Interactive namespace is empty.'
775 print 'Interactive namespace is empty.'
779 return
776 return
780
777
781 # if we have variables, move on...
778 # if we have variables, move on...
782
779
783 # stupid flushing problem: when prompts have no separators, stdout is
780 # stupid flushing problem: when prompts have no separators, stdout is
784 # getting lost. I'm starting to think this is a python bug. I'm having
781 # getting lost. I'm starting to think this is a python bug. I'm having
785 # to force a flush with a print because even a sys.stdout.flush
782 # to force a flush with a print because even a sys.stdout.flush
786 # doesn't seem to do anything!
783 # doesn't seem to do anything!
787
784
788 count = 0
785 count = 0
789 for i in varlist:
786 for i in varlist:
790 print i+'\t',
787 print i+'\t',
791 count += 1
788 count += 1
792 if count > 8:
789 if count > 8:
793 count = 0
790 count = 0
794 print
791 print
795 sys.stdout.flush() # FIXME. Why the hell isn't this flushing???
792 sys.stdout.flush() # FIXME. Why the hell isn't this flushing???
796
793
797 print # well, this does force a flush at the expense of an extra \n
794 print # well, this does force a flush at the expense of an extra \n
798
795
799 def magic_whos(self, parameter_s=''):
796 def magic_whos(self, parameter_s=''):
800 """Like %who, but gives some extra information about each variable.
797 """Like %who, but gives some extra information about each variable.
801
798
802 The same type filtering of %who can be applied here.
799 The same type filtering of %who can be applied here.
803
800
804 For all variables, the type is printed. Additionally it prints:
801 For all variables, the type is printed. Additionally it prints:
805
802
806 - For {},[],(): their length.
803 - For {},[],(): their length.
807
804
808 - For Numeric arrays, a summary with shape, number of elements,
805 - For Numeric arrays, a summary with shape, number of elements,
809 typecode and size in memory.
806 typecode and size in memory.
810
807
811 - Everything else: a string representation, snipping their middle if
808 - Everything else: a string representation, snipping their middle if
812 too long."""
809 too long."""
813
810
814 varnames = self.magic_who_ls(parameter_s)
811 varnames = self.magic_who_ls(parameter_s)
815 if not varnames:
812 if not varnames:
816 print 'Interactive namespace is empty.'
813 print 'Interactive namespace is empty.'
817 return
814 return
818
815
819 # if we have variables, move on...
816 # if we have variables, move on...
820
817
821 # for these types, show len() instead of data:
818 # for these types, show len() instead of data:
822 seq_types = [types.DictType,types.ListType,types.TupleType]
819 seq_types = [types.DictType,types.ListType,types.TupleType]
823
820
824 # for Numeric arrays, display summary info
821 # for Numeric arrays, display summary info
825 try:
822 try:
826 import Numeric
823 import Numeric
827 except ImportError:
824 except ImportError:
828 array_type = None
825 array_type = None
829 else:
826 else:
830 array_type = Numeric.ArrayType.__name__
827 array_type = Numeric.ArrayType.__name__
831
828
832 # Find all variable names and types so we can figure out column sizes
829 # Find all variable names and types so we can figure out column sizes
833 get_vars = lambda i: self.shell.user_ns[i]
830 get_vars = lambda i: self.shell.user_ns[i]
834 type_name = lambda v: type(v).__name__
831 type_name = lambda v: type(v).__name__
835 varlist = map(get_vars,varnames)
832 varlist = map(get_vars,varnames)
836
833
837 typelist = []
834 typelist = []
838 for vv in varlist:
835 for vv in varlist:
839 tt = type_name(vv)
836 tt = type_name(vv)
840 if tt=='instance':
837 if tt=='instance':
841 typelist.append(str(vv.__class__))
838 typelist.append(str(vv.__class__))
842 else:
839 else:
843 typelist.append(tt)
840 typelist.append(tt)
844
841
845 # column labels and # of spaces as separator
842 # column labels and # of spaces as separator
846 varlabel = 'Variable'
843 varlabel = 'Variable'
847 typelabel = 'Type'
844 typelabel = 'Type'
848 datalabel = 'Data/Info'
845 datalabel = 'Data/Info'
849 colsep = 3
846 colsep = 3
850 # variable format strings
847 # variable format strings
851 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
848 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
852 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
849 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
853 aformat = "%s: %s elems, type `%s`, %s bytes"
850 aformat = "%s: %s elems, type `%s`, %s bytes"
854 # find the size of the columns to format the output nicely
851 # find the size of the columns to format the output nicely
855 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
852 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
856 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
853 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
857 # table header
854 # table header
858 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
855 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
859 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
856 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
860 # and the table itself
857 # and the table itself
861 kb = 1024
858 kb = 1024
862 Mb = 1048576 # kb**2
859 Mb = 1048576 # kb**2
863 for vname,var,vtype in zip(varnames,varlist,typelist):
860 for vname,var,vtype in zip(varnames,varlist,typelist):
864 print itpl(vformat),
861 print itpl(vformat),
865 if vtype in seq_types:
862 if vtype in seq_types:
866 print len(var)
863 print len(var)
867 elif vtype==array_type:
864 elif vtype==array_type:
868 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
865 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
869 vsize = Numeric.size(var)
866 vsize = Numeric.size(var)
870 vbytes = vsize*var.itemsize()
867 vbytes = vsize*var.itemsize()
871 if vbytes < 100000:
868 if vbytes < 100000:
872 print aformat % (vshape,vsize,var.typecode(),vbytes)
869 print aformat % (vshape,vsize,var.typecode(),vbytes)
873 else:
870 else:
874 print aformat % (vshape,vsize,var.typecode(),vbytes),
871 print aformat % (vshape,vsize,var.typecode(),vbytes),
875 if vbytes < Mb:
872 if vbytes < Mb:
876 print '(%s kb)' % (vbytes/kb,)
873 print '(%s kb)' % (vbytes/kb,)
877 else:
874 else:
878 print '(%s Mb)' % (vbytes/Mb,)
875 print '(%s Mb)' % (vbytes/Mb,)
879 else:
876 else:
880 vstr = str(var).replace('\n','\\n')
877 vstr = str(var).replace('\n','\\n')
881 if len(vstr) < 50:
878 if len(vstr) < 50:
882 print vstr
879 print vstr
883 else:
880 else:
884 printpl(vfmt_short)
881 printpl(vfmt_short)
885
882
886 def magic_reset(self, parameter_s=''):
883 def magic_reset(self, parameter_s=''):
887 """Resets the namespace by removing all names defined by the user.
884 """Resets the namespace by removing all names defined by the user.
888
885
889 Input/Output history are left around in case you need them."""
886 Input/Output history are left around in case you need them."""
890
887
891 ans = raw_input(
888 ans = raw_input(
892 "Once deleted, variables cannot be recovered. Proceed (y/n)? ")
889 "Once deleted, variables cannot be recovered. Proceed (y/n)? ")
893 if not ans.lower() == 'y':
890 if not ans.lower() == 'y':
894 print 'Nothing done.'
891 print 'Nothing done.'
895 return
892 return
896 user_ns = self.shell.user_ns
893 user_ns = self.shell.user_ns
897 for i in self.magic_who_ls():
894 for i in self.magic_who_ls():
898 del(user_ns[i])
895 del(user_ns[i])
899
896
900 def magic_config(self,parameter_s=''):
897 def magic_config(self,parameter_s=''):
901 """Show IPython's internal configuration."""
898 """Show IPython's internal configuration."""
902
899
903 page('Current configuration structure:\n'+
900 page('Current configuration structure:\n'+
904 pformat(self.shell.rc.dict()))
901 pformat(self.shell.rc.dict()))
905
902
906 def magic_logstart(self,parameter_s=''):
903 def magic_logstart(self,parameter_s=''):
907 """Start logging anywhere in a session.
904 """Start logging anywhere in a session.
908
905
909 %logstart [-o|-t] [log_name [log_mode]]
906 %logstart [-o|-t] [log_name [log_mode]]
910
907
911 If no name is given, it defaults to a file named 'ipython_log.py' in your
908 If no name is given, it defaults to a file named 'ipython_log.py' in your
912 current directory, in 'rotate' mode (see below).
909 current directory, in 'rotate' mode (see below).
913
910
914 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
911 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
915 history up to that point and then continues logging.
912 history up to that point and then continues logging.
916
913
917 %logstart takes a second optional parameter: logging mode. This can be one
914 %logstart takes a second optional parameter: logging mode. This can be one
918 of (note that the modes are given unquoted):\\
915 of (note that the modes are given unquoted):\\
919 append: well, that says it.\\
916 append: well, that says it.\\
920 backup: rename (if exists) to name~ and start name.\\
917 backup: rename (if exists) to name~ and start name.\\
921 global: single logfile in your home dir, appended to.\\
918 global: single logfile in your home dir, appended to.\\
922 over : overwrite existing log.\\
919 over : overwrite existing log.\\
923 rotate: create rotating logs name.1~, name.2~, etc.
920 rotate: create rotating logs name.1~, name.2~, etc.
924
921
925 Options:
922 Options:
926
923
927 -o: log also IPython's output. In this mode, all commands which
924 -o: log also IPython's output. In this mode, all commands which
928 generate an Out[NN] prompt are recorded to the logfile, right after
925 generate an Out[NN] prompt are recorded to the logfile, right after
929 their corresponding input line. The output lines are always
926 their corresponding input line. The output lines are always
930 prepended with a '#[Out]# ' marker, so that the log remains valid
927 prepended with a '#[Out]# ' marker, so that the log remains valid
931 Python code.
928 Python code.
932
929
933 Since this marker is always the same, filtering only the output from
930 Since this marker is always the same, filtering only the output from
934 a log is very easy, using for example a simple awk call:
931 a log is very easy, using for example a simple awk call:
935
932
936 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
933 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
937
934
938 -t: put timestamps before each input line logged (these are put in
935 -t: put timestamps before each input line logged (these are put in
939 comments)."""
936 comments)."""
940
937
941 opts,par = self.parse_options(parameter_s,'ot')
938 opts,par = self.parse_options(parameter_s,'ot')
942 log_output = 'o' in opts
939 log_output = 'o' in opts
943 timestamp = 't' in opts
940 timestamp = 't' in opts
944
941
945 rc = self.shell.rc
942 rc = self.shell.rc
946 logger = self.shell.logger
943 logger = self.shell.logger
947
944
948 # if no args are given, the defaults set in the logger constructor by
945 # if no args are given, the defaults set in the logger constructor by
949 # ipytohn remain valid
946 # ipytohn remain valid
950 if par:
947 if par:
951 try:
948 try:
952 logfname,logmode = par.split()
949 logfname,logmode = par.split()
953 except:
950 except:
954 logfname = par
951 logfname = par
955 logmode = 'backup'
952 logmode = 'backup'
956 else:
953 else:
957 logfname = logger.logfname
954 logfname = logger.logfname
958 logmode = logger.logmode
955 logmode = logger.logmode
959 # put logfname into rc struct as if it had been called on the command
956 # put logfname into rc struct as if it had been called on the command
960 # line, so it ends up saved in the log header Save it in case we need
957 # line, so it ends up saved in the log header Save it in case we need
961 # to restore it...
958 # to restore it...
962 old_logfile = rc.opts.get('logfile','')
959 old_logfile = rc.opts.get('logfile','')
963 if logfname:
960 if logfname:
964 logfname = os.path.expanduser(logfname)
961 logfname = os.path.expanduser(logfname)
965 rc.opts.logfile = logfname
962 rc.opts.logfile = logfname
966 loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
963 loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
967 try:
964 try:
968 started = logger.logstart(logfname,loghead,logmode,
965 started = logger.logstart(logfname,loghead,logmode,
969 log_output,timestamp)
966 log_output,timestamp)
970 except:
967 except:
971 rc.opts.logfile = old_logfile
968 rc.opts.logfile = old_logfile
972 warn("Couldn't start log: %s" % sys.exc_info()[1])
969 warn("Couldn't start log: %s" % sys.exc_info()[1])
973 else:
970 else:
974 # log input history up to this point, optionally interleaving
971 # log input history up to this point, optionally interleaving
975 # output if requested
972 # output if requested
976
973
977 if timestamp:
974 if timestamp:
978 # disable timestamping for the previous history, since we've
975 # disable timestamping for the previous history, since we've
979 # lost those already (no time machine here).
976 # lost those already (no time machine here).
980 logger.timestamp = False
977 logger.timestamp = False
981 if log_output:
978 if log_output:
982 log_write = logger.log_write
979 log_write = logger.log_write
983 input_hist = self.shell.input_hist
980 input_hist = self.shell.input_hist
984 output_hist = self.shell.output_hist
981 output_hist = self.shell.output_hist
985 for n in range(1,len(input_hist)-1):
982 for n in range(1,len(input_hist)-1):
986 log_write(input_hist[n].rstrip())
983 log_write(input_hist[n].rstrip())
987 if n in output_hist:
984 if n in output_hist:
988 log_write(repr(output_hist[n]),'output')
985 log_write(repr(output_hist[n]),'output')
989 else:
986 else:
990 logger.log_write(self.shell.input_hist[1:])
987 logger.log_write(self.shell.input_hist[1:])
991 if timestamp:
988 if timestamp:
992 # re-enable timestamping
989 # re-enable timestamping
993 logger.timestamp = True
990 logger.timestamp = True
994
991
995 print ('Activating auto-logging. '
992 print ('Activating auto-logging. '
996 'Current session state plus future input saved.')
993 'Current session state plus future input saved.')
997 logger.logstate()
994 logger.logstate()
998
995
999 def magic_logoff(self,parameter_s=''):
996 def magic_logoff(self,parameter_s=''):
1000 """Temporarily stop logging.
997 """Temporarily stop logging.
1001
998
1002 You must have previously started logging."""
999 You must have previously started logging."""
1003 self.shell.logger.switch_log(0)
1000 self.shell.logger.switch_log(0)
1004
1001
1005 def magic_logon(self,parameter_s=''):
1002 def magic_logon(self,parameter_s=''):
1006 """Restart logging.
1003 """Restart logging.
1007
1004
1008 This function is for restarting logging which you've temporarily
1005 This function is for restarting logging which you've temporarily
1009 stopped with %logoff. For starting logging for the first time, you
1006 stopped with %logoff. For starting logging for the first time, you
1010 must use the %logstart function, which allows you to specify an
1007 must use the %logstart function, which allows you to specify an
1011 optional log filename."""
1008 optional log filename."""
1012
1009
1013 self.shell.logger.switch_log(1)
1010 self.shell.logger.switch_log(1)
1014
1011
1015 def magic_logstate(self,parameter_s=''):
1012 def magic_logstate(self,parameter_s=''):
1016 """Print the status of the logging system."""
1013 """Print the status of the logging system."""
1017
1014
1018 self.shell.logger.logstate()
1015 self.shell.logger.logstate()
1019
1016
1020 def magic_pdb(self, parameter_s=''):
1017 def magic_pdb(self, parameter_s=''):
1021 """Control the calling of the pdb interactive debugger.
1018 """Control the calling of the pdb interactive debugger.
1022
1019
1023 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1020 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1024 argument it works as a toggle.
1021 argument it works as a toggle.
1025
1022
1026 When an exception is triggered, IPython can optionally call the
1023 When an exception is triggered, IPython can optionally call the
1027 interactive pdb debugger after the traceback printout. %pdb toggles
1024 interactive pdb debugger after the traceback printout. %pdb toggles
1028 this feature on and off."""
1025 this feature on and off."""
1029
1026
1030 par = parameter_s.strip().lower()
1027 par = parameter_s.strip().lower()
1031
1028
1032 if par:
1029 if par:
1033 try:
1030 try:
1034 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1031 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1035 except KeyError:
1032 except KeyError:
1036 print ('Incorrect argument. Use on/1, off/0, '
1033 print ('Incorrect argument. Use on/1, off/0, '
1037 'or nothing for a toggle.')
1034 'or nothing for a toggle.')
1038 return
1035 return
1039 else:
1036 else:
1040 # toggle
1037 # toggle
1041 new_pdb = not self.shell.InteractiveTB.call_pdb
1038 new_pdb = not self.shell.InteractiveTB.call_pdb
1042
1039
1043 # set on the shell
1040 # set on the shell
1044 self.shell.call_pdb = new_pdb
1041 self.shell.call_pdb = new_pdb
1045 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1042 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1046
1043
1047 def magic_prun(self, parameter_s ='',user_mode=1,
1044 def magic_prun(self, parameter_s ='',user_mode=1,
1048 opts=None,arg_lst=None,prog_ns=None):
1045 opts=None,arg_lst=None,prog_ns=None):
1049
1046
1050 """Run a statement through the python code profiler.
1047 """Run a statement through the python code profiler.
1051
1048
1052 Usage:\\
1049 Usage:\\
1053 %prun [options] statement
1050 %prun [options] statement
1054
1051
1055 The given statement (which doesn't require quote marks) is run via the
1052 The given statement (which doesn't require quote marks) is run via the
1056 python profiler in a manner similar to the profile.run() function.
1053 python profiler in a manner similar to the profile.run() function.
1057 Namespaces are internally managed to work correctly; profile.run
1054 Namespaces are internally managed to work correctly; profile.run
1058 cannot be used in IPython because it makes certain assumptions about
1055 cannot be used in IPython because it makes certain assumptions about
1059 namespaces which do not hold under IPython.
1056 namespaces which do not hold under IPython.
1060
1057
1061 Options:
1058 Options:
1062
1059
1063 -l <limit>: you can place restrictions on what or how much of the
1060 -l <limit>: you can place restrictions on what or how much of the
1064 profile gets printed. The limit value can be:
1061 profile gets printed. The limit value can be:
1065
1062
1066 * A string: only information for function names containing this string
1063 * A string: only information for function names containing this string
1067 is printed.
1064 is printed.
1068
1065
1069 * An integer: only these many lines are printed.
1066 * An integer: only these many lines are printed.
1070
1067
1071 * A float (between 0 and 1): this fraction of the report is printed
1068 * A float (between 0 and 1): this fraction of the report is printed
1072 (for example, use a limit of 0.4 to see the topmost 40% only).
1069 (for example, use a limit of 0.4 to see the topmost 40% only).
1073
1070
1074 You can combine several limits with repeated use of the option. For
1071 You can combine several limits with repeated use of the option. For
1075 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1072 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1076 information about class constructors.
1073 information about class constructors.
1077
1074
1078 -r: return the pstats.Stats object generated by the profiling. This
1075 -r: return the pstats.Stats object generated by the profiling. This
1079 object has all the information about the profile in it, and you can
1076 object has all the information about the profile in it, and you can
1080 later use it for further analysis or in other functions.
1077 later use it for further analysis or in other functions.
1081
1078
1082 Since magic functions have a particular form of calling which prevents
1079 Since magic functions have a particular form of calling which prevents
1083 you from writing something like:\\
1080 you from writing something like:\\
1084 In [1]: p = %prun -r print 4 # invalid!\\
1081 In [1]: p = %prun -r print 4 # invalid!\\
1085 you must instead use IPython's automatic variables to assign this:\\
1082 you must instead use IPython's automatic variables to assign this:\\
1086 In [1]: %prun -r print 4 \\
1083 In [1]: %prun -r print 4 \\
1087 Out[1]: <pstats.Stats instance at 0x8222cec>\\
1084 Out[1]: <pstats.Stats instance at 0x8222cec>\\
1088 In [2]: stats = _
1085 In [2]: stats = _
1089
1086
1090 If you really need to assign this value via an explicit function call,
1087 If you really need to assign this value via an explicit function call,
1091 you can always tap directly into the true name of the magic function
1088 you can always tap directly into the true name of the magic function
1092 by using the ipmagic function (which IPython automatically adds to the
1089 by using the ipmagic function (which IPython automatically adds to the
1093 builtins):\\
1090 builtins):\\
1094 In [3]: stats = ipmagic('prun','-r print 4')
1091 In [3]: stats = ipmagic('prun','-r print 4')
1095
1092
1096 You can type ipmagic? for more details on ipmagic.
1093 You can type ipmagic? for more details on ipmagic.
1097
1094
1098 -s <key>: sort profile by given key. You can provide more than one key
1095 -s <key>: sort profile by given key. You can provide more than one key
1099 by using the option several times: '-s key1 -s key2 -s key3...'. The
1096 by using the option several times: '-s key1 -s key2 -s key3...'. The
1100 default sorting key is 'time'.
1097 default sorting key is 'time'.
1101
1098
1102 The following is copied verbatim from the profile documentation
1099 The following is copied verbatim from the profile documentation
1103 referenced below:
1100 referenced below:
1104
1101
1105 When more than one key is provided, additional keys are used as
1102 When more than one key is provided, additional keys are used as
1106 secondary criteria when the there is equality in all keys selected
1103 secondary criteria when the there is equality in all keys selected
1107 before them.
1104 before them.
1108
1105
1109 Abbreviations can be used for any key names, as long as the
1106 Abbreviations can be used for any key names, as long as the
1110 abbreviation is unambiguous. The following are the keys currently
1107 abbreviation is unambiguous. The following are the keys currently
1111 defined:
1108 defined:
1112
1109
1113 Valid Arg Meaning\\
1110 Valid Arg Meaning\\
1114 "calls" call count\\
1111 "calls" call count\\
1115 "cumulative" cumulative time\\
1112 "cumulative" cumulative time\\
1116 "file" file name\\
1113 "file" file name\\
1117 "module" file name\\
1114 "module" file name\\
1118 "pcalls" primitive call count\\
1115 "pcalls" primitive call count\\
1119 "line" line number\\
1116 "line" line number\\
1120 "name" function name\\
1117 "name" function name\\
1121 "nfl" name/file/line\\
1118 "nfl" name/file/line\\
1122 "stdname" standard name\\
1119 "stdname" standard name\\
1123 "time" internal time
1120 "time" internal time
1124
1121
1125 Note that all sorts on statistics are in descending order (placing
1122 Note that all sorts on statistics are in descending order (placing
1126 most time consuming items first), where as name, file, and line number
1123 most time consuming items first), where as name, file, and line number
1127 searches are in ascending order (i.e., alphabetical). The subtle
1124 searches are in ascending order (i.e., alphabetical). The subtle
1128 distinction between "nfl" and "stdname" is that the standard name is a
1125 distinction between "nfl" and "stdname" is that the standard name is a
1129 sort of the name as printed, which means that the embedded line
1126 sort of the name as printed, which means that the embedded line
1130 numbers get compared in an odd way. For example, lines 3, 20, and 40
1127 numbers get compared in an odd way. For example, lines 3, 20, and 40
1131 would (if the file names were the same) appear in the string order
1128 would (if the file names were the same) appear in the string order
1132 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1129 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1133 line numbers. In fact, sort_stats("nfl") is the same as
1130 line numbers. In fact, sort_stats("nfl") is the same as
1134 sort_stats("name", "file", "line").
1131 sort_stats("name", "file", "line").
1135
1132
1136 -T <filename>: save profile results as shown on screen to a text
1133 -T <filename>: save profile results as shown on screen to a text
1137 file. The profile is still shown on screen.
1134 file. The profile is still shown on screen.
1138
1135
1139 -D <filename>: save (via dump_stats) profile statistics to given
1136 -D <filename>: save (via dump_stats) profile statistics to given
1140 filename. This data is in a format understod by the pstats module, and
1137 filename. This data is in a format understod by the pstats module, and
1141 is generated by a call to the dump_stats() method of profile
1138 is generated by a call to the dump_stats() method of profile
1142 objects. The profile is still shown on screen.
1139 objects. The profile is still shown on screen.
1143
1140
1144 If you want to run complete programs under the profiler's control, use
1141 If you want to run complete programs under the profiler's control, use
1145 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1142 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1146 contains profiler specific options as described here.
1143 contains profiler specific options as described here.
1147
1144
1148 You can read the complete documentation for the profile module with:\\
1145 You can read the complete documentation for the profile module with:\\
1149 In [1]: import profile; profile.help() """
1146 In [1]: import profile; profile.help() """
1150
1147
1151 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1148 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1152 # protect user quote marks
1149 # protect user quote marks
1153 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1150 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1154
1151
1155 if user_mode: # regular user call
1152 if user_mode: # regular user call
1156 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1153 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1157 list_all=1)
1154 list_all=1)
1158 namespace = self.shell.user_ns
1155 namespace = self.shell.user_ns
1159 else: # called to run a program by %run -p
1156 else: # called to run a program by %run -p
1160 try:
1157 try:
1161 filename = get_py_filename(arg_lst[0])
1158 filename = get_py_filename(arg_lst[0])
1162 except IOError,msg:
1159 except IOError,msg:
1163 error(msg)
1160 error(msg)
1164 return
1161 return
1165
1162
1166 arg_str = 'execfile(filename,prog_ns)'
1163 arg_str = 'execfile(filename,prog_ns)'
1167 namespace = locals()
1164 namespace = locals()
1168
1165
1169 opts.merge(opts_def)
1166 opts.merge(opts_def)
1170
1167
1171 prof = profile.Profile()
1168 prof = profile.Profile()
1172 try:
1169 try:
1173 prof = prof.runctx(arg_str,namespace,namespace)
1170 prof = prof.runctx(arg_str,namespace,namespace)
1174 sys_exit = ''
1171 sys_exit = ''
1175 except SystemExit:
1172 except SystemExit:
1176 sys_exit = """*** SystemExit exception caught in code being profiled."""
1173 sys_exit = """*** SystemExit exception caught in code being profiled."""
1177
1174
1178 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1175 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1179
1176
1180 lims = opts.l
1177 lims = opts.l
1181 if lims:
1178 if lims:
1182 lims = [] # rebuild lims with ints/floats/strings
1179 lims = [] # rebuild lims with ints/floats/strings
1183 for lim in opts.l:
1180 for lim in opts.l:
1184 try:
1181 try:
1185 lims.append(int(lim))
1182 lims.append(int(lim))
1186 except ValueError:
1183 except ValueError:
1187 try:
1184 try:
1188 lims.append(float(lim))
1185 lims.append(float(lim))
1189 except ValueError:
1186 except ValueError:
1190 lims.append(lim)
1187 lims.append(lim)
1191
1188
1192 # trap output
1189 # trap output
1193 sys_stdout = sys.stdout
1190 sys_stdout = sys.stdout
1194 stdout_trap = StringIO()
1191 stdout_trap = StringIO()
1195 try:
1192 try:
1196 sys.stdout = stdout_trap
1193 sys.stdout = stdout_trap
1197 stats.print_stats(*lims)
1194 stats.print_stats(*lims)
1198 finally:
1195 finally:
1199 sys.stdout = sys_stdout
1196 sys.stdout = sys_stdout
1200 output = stdout_trap.getvalue()
1197 output = stdout_trap.getvalue()
1201 output = output.rstrip()
1198 output = output.rstrip()
1202
1199
1203 page(output,screen_lines=self.shell.rc.screen_length)
1200 page(output,screen_lines=self.shell.rc.screen_length)
1204 print sys_exit,
1201 print sys_exit,
1205
1202
1206 dump_file = opts.D[0]
1203 dump_file = opts.D[0]
1207 text_file = opts.T[0]
1204 text_file = opts.T[0]
1208 if dump_file:
1205 if dump_file:
1209 prof.dump_stats(dump_file)
1206 prof.dump_stats(dump_file)
1210 print '\n*** Profile stats marshalled to file',\
1207 print '\n*** Profile stats marshalled to file',\
1211 `dump_file`+'.',sys_exit
1208 `dump_file`+'.',sys_exit
1212 if text_file:
1209 if text_file:
1213 file(text_file,'w').write(output)
1210 file(text_file,'w').write(output)
1214 print '\n*** Profile printout saved to text file',\
1211 print '\n*** Profile printout saved to text file',\
1215 `text_file`+'.',sys_exit
1212 `text_file`+'.',sys_exit
1216
1213
1217 if opts.has_key('r'):
1214 if opts.has_key('r'):
1218 return stats
1215 return stats
1219 else:
1216 else:
1220 return None
1217 return None
1221
1218
1222 def magic_run(self, parameter_s ='',runner=None):
1219 def magic_run(self, parameter_s ='',runner=None):
1223 """Run the named file inside IPython as a program.
1220 """Run the named file inside IPython as a program.
1224
1221
1225 Usage:\\
1222 Usage:\\
1226 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1223 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1227
1224
1228 Parameters after the filename are passed as command-line arguments to
1225 Parameters after the filename are passed as command-line arguments to
1229 the program (put in sys.argv). Then, control returns to IPython's
1226 the program (put in sys.argv). Then, control returns to IPython's
1230 prompt.
1227 prompt.
1231
1228
1232 This is similar to running at a system prompt:\\
1229 This is similar to running at a system prompt:\\
1233 $ python file args\\
1230 $ python file args\\
1234 but with the advantage of giving you IPython's tracebacks, and of
1231 but with the advantage of giving you IPython's tracebacks, and of
1235 loading all variables into your interactive namespace for further use
1232 loading all variables into your interactive namespace for further use
1236 (unless -p is used, see below).
1233 (unless -p is used, see below).
1237
1234
1238 The file is executed in a namespace initially consisting only of
1235 The file is executed in a namespace initially consisting only of
1239 __name__=='__main__' and sys.argv constructed as indicated. It thus
1236 __name__=='__main__' and sys.argv constructed as indicated. It thus
1240 sees its environment as if it were being run as a stand-alone
1237 sees its environment as if it were being run as a stand-alone
1241 program. But after execution, the IPython interactive namespace gets
1238 program. But after execution, the IPython interactive namespace gets
1242 updated with all variables defined in the program (except for __name__
1239 updated with all variables defined in the program (except for __name__
1243 and sys.argv). This allows for very convenient loading of code for
1240 and sys.argv). This allows for very convenient loading of code for
1244 interactive work, while giving each program a 'clean sheet' to run in.
1241 interactive work, while giving each program a 'clean sheet' to run in.
1245
1242
1246 Options:
1243 Options:
1247
1244
1248 -n: __name__ is NOT set to '__main__', but to the running file's name
1245 -n: __name__ is NOT set to '__main__', but to the running file's name
1249 without extension (as python does under import). This allows running
1246 without extension (as python does under import). This allows running
1250 scripts and reloading the definitions in them without calling code
1247 scripts and reloading the definitions in them without calling code
1251 protected by an ' if __name__ == "__main__" ' clause.
1248 protected by an ' if __name__ == "__main__" ' clause.
1252
1249
1253 -i: run the file in IPython's namespace instead of an empty one. This
1250 -i: run the file in IPython's namespace instead of an empty one. This
1254 is useful if you are experimenting with code written in a text editor
1251 is useful if you are experimenting with code written in a text editor
1255 which depends on variables defined interactively.
1252 which depends on variables defined interactively.
1256
1253
1257 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1254 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1258 being run. This is particularly useful if IPython is being used to
1255 being run. This is particularly useful if IPython is being used to
1259 run unittests, which always exit with a sys.exit() call. In such
1256 run unittests, which always exit with a sys.exit() call. In such
1260 cases you are interested in the output of the test results, not in
1257 cases you are interested in the output of the test results, not in
1261 seeing a traceback of the unittest module.
1258 seeing a traceback of the unittest module.
1262
1259
1263 -t: print timing information at the end of the run. IPython will give
1260 -t: print timing information at the end of the run. IPython will give
1264 you an estimated CPU time consumption for your script, which under
1261 you an estimated CPU time consumption for your script, which under
1265 Unix uses the resource module to avoid the wraparound problems of
1262 Unix uses the resource module to avoid the wraparound problems of
1266 time.clock(). Under Unix, an estimate of time spent on system tasks
1263 time.clock(). Under Unix, an estimate of time spent on system tasks
1267 is also given (for Windows platforms this is reported as 0.0).
1264 is also given (for Windows platforms this is reported as 0.0).
1268
1265
1269 If -t is given, an additional -N<N> option can be given, where <N>
1266 If -t is given, an additional -N<N> option can be given, where <N>
1270 must be an integer indicating how many times you want the script to
1267 must be an integer indicating how many times you want the script to
1271 run. The final timing report will include total and per run results.
1268 run. The final timing report will include total and per run results.
1272
1269
1273 For example (testing the script uniq_stable.py):
1270 For example (testing the script uniq_stable.py):
1274
1271
1275 In [1]: run -t uniq_stable
1272 In [1]: run -t uniq_stable
1276
1273
1277 IPython CPU timings (estimated):\\
1274 IPython CPU timings (estimated):\\
1278 User : 0.19597 s.\\
1275 User : 0.19597 s.\\
1279 System: 0.0 s.\\
1276 System: 0.0 s.\\
1280
1277
1281 In [2]: run -t -N5 uniq_stable
1278 In [2]: run -t -N5 uniq_stable
1282
1279
1283 IPython CPU timings (estimated):\\
1280 IPython CPU timings (estimated):\\
1284 Total runs performed: 5\\
1281 Total runs performed: 5\\
1285 Times : Total Per run\\
1282 Times : Total Per run\\
1286 User : 0.910862 s, 0.1821724 s.\\
1283 User : 0.910862 s, 0.1821724 s.\\
1287 System: 0.0 s, 0.0 s.
1284 System: 0.0 s, 0.0 s.
1288
1285
1289 -d: run your program under the control of pdb, the Python debugger.
1286 -d: run your program under the control of pdb, the Python debugger.
1290 This allows you to execute your program step by step, watch variables,
1287 This allows you to execute your program step by step, watch variables,
1291 etc. Internally, what IPython does is similar to calling:
1288 etc. Internally, what IPython does is similar to calling:
1292
1289
1293 pdb.run('execfile("YOURFILENAME")')
1290 pdb.run('execfile("YOURFILENAME")')
1294
1291
1295 with a breakpoint set on line 1 of your file. You can change the line
1292 with a breakpoint set on line 1 of your file. You can change the line
1296 number for this automatic breakpoint to be <N> by using the -bN option
1293 number for this automatic breakpoint to be <N> by using the -bN option
1297 (where N must be an integer). For example:
1294 (where N must be an integer). For example:
1298
1295
1299 %run -d -b40 myscript
1296 %run -d -b40 myscript
1300
1297
1301 will set the first breakpoint at line 40 in myscript.py. Note that
1298 will set the first breakpoint at line 40 in myscript.py. Note that
1302 the first breakpoint must be set on a line which actually does
1299 the first breakpoint must be set on a line which actually does
1303 something (not a comment or docstring) for it to stop execution.
1300 something (not a comment or docstring) for it to stop execution.
1304
1301
1305 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1302 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1306 first enter 'c' (without qoutes) to start execution up to the first
1303 first enter 'c' (without qoutes) to start execution up to the first
1307 breakpoint.
1304 breakpoint.
1308
1305
1309 Entering 'help' gives information about the use of the debugger. You
1306 Entering 'help' gives information about the use of the debugger. You
1310 can easily see pdb's full documentation with "import pdb;pdb.help()"
1307 can easily see pdb's full documentation with "import pdb;pdb.help()"
1311 at a prompt.
1308 at a prompt.
1312
1309
1313 -p: run program under the control of the Python profiler module (which
1310 -p: run program under the control of the Python profiler module (which
1314 prints a detailed report of execution times, function calls, etc).
1311 prints a detailed report of execution times, function calls, etc).
1315
1312
1316 You can pass other options after -p which affect the behavior of the
1313 You can pass other options after -p which affect the behavior of the
1317 profiler itself. See the docs for %prun for details.
1314 profiler itself. See the docs for %prun for details.
1318
1315
1319 In this mode, the program's variables do NOT propagate back to the
1316 In this mode, the program's variables do NOT propagate back to the
1320 IPython interactive namespace (because they remain in the namespace
1317 IPython interactive namespace (because they remain in the namespace
1321 where the profiler executes them).
1318 where the profiler executes them).
1322
1319
1323 Internally this triggers a call to %prun, see its documentation for
1320 Internally this triggers a call to %prun, see its documentation for
1324 details on the options available specifically for profiling."""
1321 details on the options available specifically for profiling."""
1325
1322
1326 # get arguments and set sys.argv for program to be run.
1323 # get arguments and set sys.argv for program to be run.
1327 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1324 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1328 mode='list',list_all=1)
1325 mode='list',list_all=1)
1329
1326
1330 try:
1327 try:
1331 filename = get_py_filename(arg_lst[0])
1328 filename = get_py_filename(arg_lst[0])
1332 except IndexError:
1329 except IndexError:
1333 warn('you must provide at least a filename.')
1330 warn('you must provide at least a filename.')
1334 print '\n%run:\n',OInspect.getdoc(self.magic_run)
1331 print '\n%run:\n',OInspect.getdoc(self.magic_run)
1335 return
1332 return
1336 except IOError,msg:
1333 except IOError,msg:
1337 error(msg)
1334 error(msg)
1338 return
1335 return
1339
1336
1340 # Control the response to exit() calls made by the script being run
1337 # Control the response to exit() calls made by the script being run
1341 exit_ignore = opts.has_key('e')
1338 exit_ignore = opts.has_key('e')
1342
1339
1343 # Make sure that the running script gets a proper sys.argv as if it
1340 # Make sure that the running script gets a proper sys.argv as if it
1344 # were run from a system shell.
1341 # were run from a system shell.
1345 save_argv = sys.argv # save it for later restoring
1342 save_argv = sys.argv # save it for later restoring
1346 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1343 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1347
1344
1348 if opts.has_key('i'):
1345 if opts.has_key('i'):
1349 prog_ns = self.shell.user_ns
1346 prog_ns = self.shell.user_ns
1350 __name__save = self.shell.user_ns['__name__']
1347 __name__save = self.shell.user_ns['__name__']
1351 prog_ns['__name__'] = '__main__'
1348 prog_ns['__name__'] = '__main__'
1352 else:
1349 else:
1353 if opts.has_key('n'):
1350 if opts.has_key('n'):
1354 name = os.path.splitext(os.path.basename(filename))[0]
1351 name = os.path.splitext(os.path.basename(filename))[0]
1355 else:
1352 else:
1356 name = '__main__'
1353 name = '__main__'
1357 prog_ns = {'__name__':name}
1354 prog_ns = {'__name__':name}
1358
1355
1359 # pickle fix. See iplib for an explanation
1356 # pickle fix. See iplib for an explanation. But we need to make sure
1357 # that, if we overwrite __main__, we replace it at the end
1358 if prog_ns['__name__'] == '__main__':
1359 restore_main = sys.modules['__main__']
1360 else:
1361 restore_main = False
1362
1360 sys.modules[prog_ns['__name__']] = FakeModule(prog_ns)
1363 sys.modules[prog_ns['__name__']] = FakeModule(prog_ns)
1361
1364
1362 stats = None
1365 stats = None
1363 try:
1366 try:
1364 if opts.has_key('p'):
1367 if opts.has_key('p'):
1365 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1368 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1366 else:
1369 else:
1367 if opts.has_key('d'):
1370 if opts.has_key('d'):
1368 deb = Debugger.Pdb(self.shell.rc.colors)
1371 deb = Debugger.Pdb(self.shell.rc.colors)
1369 # reset Breakpoint state, which is moronically kept
1372 # reset Breakpoint state, which is moronically kept
1370 # in a class
1373 # in a class
1371 bdb.Breakpoint.next = 1
1374 bdb.Breakpoint.next = 1
1372 bdb.Breakpoint.bplist = {}
1375 bdb.Breakpoint.bplist = {}
1373 bdb.Breakpoint.bpbynumber = [None]
1376 bdb.Breakpoint.bpbynumber = [None]
1374 # Set an initial breakpoint to stop execution
1377 # Set an initial breakpoint to stop execution
1375 maxtries = 10
1378 maxtries = 10
1376 bp = int(opts.get('b',[1])[0])
1379 bp = int(opts.get('b',[1])[0])
1377 checkline = deb.checkline(filename,bp)
1380 checkline = deb.checkline(filename,bp)
1378 if not checkline:
1381 if not checkline:
1379 for bp in range(bp+1,bp+maxtries+1):
1382 for bp in range(bp+1,bp+maxtries+1):
1380 if deb.checkline(filename,bp):
1383 if deb.checkline(filename,bp):
1381 break
1384 break
1382 else:
1385 else:
1383 msg = ("\nI failed to find a valid line to set "
1386 msg = ("\nI failed to find a valid line to set "
1384 "a breakpoint\n"
1387 "a breakpoint\n"
1385 "after trying up to line: %s.\n"
1388 "after trying up to line: %s.\n"
1386 "Please set a valid breakpoint manually "
1389 "Please set a valid breakpoint manually "
1387 "with the -b option." % bp)
1390 "with the -b option." % bp)
1388 error(msg)
1391 error(msg)
1389 return
1392 return
1390 # if we find a good linenumber, set the breakpoint
1393 # if we find a good linenumber, set the breakpoint
1391 deb.do_break('%s:%s' % (filename,bp))
1394 deb.do_break('%s:%s' % (filename,bp))
1392 # Start file run
1395 # Start file run
1393 print "NOTE: Enter 'c' at the",
1396 print "NOTE: Enter 'c' at the",
1394 print "ipdb> prompt to start your script."
1397 print "ipdb> prompt to start your script."
1395 try:
1398 try:
1396 deb.run('execfile("%s")' % filename,prog_ns)
1399 deb.run('execfile("%s")' % filename,prog_ns)
1397 except:
1400 except:
1398 etype, value, tb = sys.exc_info()
1401 etype, value, tb = sys.exc_info()
1399 # Skip three frames in the traceback: the %run one,
1402 # Skip three frames in the traceback: the %run one,
1400 # one inside bdb.py, and the command-line typed by the
1403 # one inside bdb.py, and the command-line typed by the
1401 # user (run by exec in pdb itself).
1404 # user (run by exec in pdb itself).
1402 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1405 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1403 else:
1406 else:
1404 if runner is None:
1407 if runner is None:
1405 runner = self.shell.safe_execfile
1408 runner = self.shell.safe_execfile
1406 if opts.has_key('t'):
1409 if opts.has_key('t'):
1407 try:
1410 try:
1408 nruns = int(opts['N'][0])
1411 nruns = int(opts['N'][0])
1409 if nruns < 1:
1412 if nruns < 1:
1410 error('Number of runs must be >=1')
1413 error('Number of runs must be >=1')
1411 return
1414 return
1412 except (KeyError):
1415 except (KeyError):
1413 nruns = 1
1416 nruns = 1
1414 if nruns == 1:
1417 if nruns == 1:
1415 t0 = clock2()
1418 t0 = clock2()
1416 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1419 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1417 t1 = clock2()
1420 t1 = clock2()
1418 t_usr = t1[0]-t0[0]
1421 t_usr = t1[0]-t0[0]
1419 t_sys = t1[1]-t1[1]
1422 t_sys = t1[1]-t1[1]
1420 print "\nIPython CPU timings (estimated):"
1423 print "\nIPython CPU timings (estimated):"
1421 print " User : %10s s." % t_usr
1424 print " User : %10s s." % t_usr
1422 print " System: %10s s." % t_sys
1425 print " System: %10s s." % t_sys
1423 else:
1426 else:
1424 runs = range(nruns)
1427 runs = range(nruns)
1425 t0 = clock2()
1428 t0 = clock2()
1426 for nr in runs:
1429 for nr in runs:
1427 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1430 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1428 t1 = clock2()
1431 t1 = clock2()
1429 t_usr = t1[0]-t0[0]
1432 t_usr = t1[0]-t0[0]
1430 t_sys = t1[1]-t1[1]
1433 t_sys = t1[1]-t1[1]
1431 print "\nIPython CPU timings (estimated):"
1434 print "\nIPython CPU timings (estimated):"
1432 print "Total runs performed:",nruns
1435 print "Total runs performed:",nruns
1433 print " Times : %10s %10s" % ('Total','Per run')
1436 print " Times : %10s %10s" % ('Total','Per run')
1434 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1437 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1435 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1438 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1436
1439
1437 else:
1440 else:
1438 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1441 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1439 if opts.has_key('i'):
1442 if opts.has_key('i'):
1440 self.shell.user_ns['__name__'] = __name__save
1443 self.shell.user_ns['__name__'] = __name__save
1441 else:
1444 else:
1442 # update IPython interactive namespace
1445 # update IPython interactive namespace
1443 del prog_ns['__name__']
1446 del prog_ns['__name__']
1444 self.shell.user_ns.update(prog_ns)
1447 self.shell.user_ns.update(prog_ns)
1445 finally:
1448 finally:
1446 sys.argv = save_argv
1449 sys.argv = save_argv
1450 if restore_main:
1451 sys.modules['__main__'] = restore_main
1447 return stats
1452 return stats
1448
1453
1449 def magic_runlog(self, parameter_s =''):
1454 def magic_runlog(self, parameter_s =''):
1450 """Run files as logs.
1455 """Run files as logs.
1451
1456
1452 Usage:\\
1457 Usage:\\
1453 %runlog file1 file2 ...
1458 %runlog file1 file2 ...
1454
1459
1455 Run the named files (treating them as log files) in sequence inside
1460 Run the named files (treating them as log files) in sequence inside
1456 the interpreter, and return to the prompt. This is much slower than
1461 the interpreter, and return to the prompt. This is much slower than
1457 %run because each line is executed in a try/except block, but it
1462 %run because each line is executed in a try/except block, but it
1458 allows running files with syntax errors in them.
1463 allows running files with syntax errors in them.
1459
1464
1460 Normally IPython will guess when a file is one of its own logfiles, so
1465 Normally IPython will guess when a file is one of its own logfiles, so
1461 you can typically use %run even for logs. This shorthand allows you to
1466 you can typically use %run even for logs. This shorthand allows you to
1462 force any file to be treated as a log file."""
1467 force any file to be treated as a log file."""
1463
1468
1464 for f in parameter_s.split():
1469 for f in parameter_s.split():
1465 self.shell.safe_execfile(f,self.shell.user_ns,
1470 self.shell.safe_execfile(f,self.shell.user_ns,
1466 self.shell.user_ns,islog=1)
1471 self.shell.user_ns,islog=1)
1467
1472
1468 def magic_time(self,parameter_s = ''):
1473 def magic_time(self,parameter_s = ''):
1469 """Time execution of a Python statement or expression.
1474 """Time execution of a Python statement or expression.
1470
1475
1471 The CPU and wall clock times are printed, and the value of the
1476 The CPU and wall clock times are printed, and the value of the
1472 expression (if any) is returned. Note that under Win32, system time
1477 expression (if any) is returned. Note that under Win32, system time
1473 is always reported as 0, since it can not be measured.
1478 is always reported as 0, since it can not be measured.
1474
1479
1475 This function provides very basic timing functionality. In Python
1480 This function provides very basic timing functionality. In Python
1476 2.3, the timeit module offers more control and sophistication, but for
1481 2.3, the timeit module offers more control and sophistication, but for
1477 now IPython supports Python 2.2, so we can not rely on timeit being
1482 now IPython supports Python 2.2, so we can not rely on timeit being
1478 present.
1483 present.
1479
1484
1480 Some examples:
1485 Some examples:
1481
1486
1482 In [1]: time 2**128
1487 In [1]: time 2**128
1483 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1488 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1484 Wall time: 0.00
1489 Wall time: 0.00
1485 Out[1]: 340282366920938463463374607431768211456L
1490 Out[1]: 340282366920938463463374607431768211456L
1486
1491
1487 In [2]: n = 1000000
1492 In [2]: n = 1000000
1488
1493
1489 In [3]: time sum(range(n))
1494 In [3]: time sum(range(n))
1490 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1495 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1491 Wall time: 1.37
1496 Wall time: 1.37
1492 Out[3]: 499999500000L
1497 Out[3]: 499999500000L
1493
1498
1494 In [4]: time print 'hello world'
1499 In [4]: time print 'hello world'
1495 hello world
1500 hello world
1496 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1501 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1497 Wall time: 0.00
1502 Wall time: 0.00
1498 """
1503 """
1499
1504
1500 # fail immediately if the given expression can't be compiled
1505 # fail immediately if the given expression can't be compiled
1501 try:
1506 try:
1502 mode = 'eval'
1507 mode = 'eval'
1503 code = compile(parameter_s,'<timed eval>',mode)
1508 code = compile(parameter_s,'<timed eval>',mode)
1504 except SyntaxError:
1509 except SyntaxError:
1505 mode = 'exec'
1510 mode = 'exec'
1506 code = compile(parameter_s,'<timed exec>',mode)
1511 code = compile(parameter_s,'<timed exec>',mode)
1507 # skew measurement as little as possible
1512 # skew measurement as little as possible
1508 glob = self.shell.user_ns
1513 glob = self.shell.user_ns
1509 clk = clock2
1514 clk = clock2
1510 wtime = time.time
1515 wtime = time.time
1511 # time execution
1516 # time execution
1512 wall_st = wtime()
1517 wall_st = wtime()
1513 if mode=='eval':
1518 if mode=='eval':
1514 st = clk()
1519 st = clk()
1515 out = eval(code,glob)
1520 out = eval(code,glob)
1516 end = clk()
1521 end = clk()
1517 else:
1522 else:
1518 st = clk()
1523 st = clk()
1519 exec code in glob
1524 exec code in glob
1520 end = clk()
1525 end = clk()
1521 out = None
1526 out = None
1522 wall_end = wtime()
1527 wall_end = wtime()
1523 # Compute actual times and report
1528 # Compute actual times and report
1524 wall_time = wall_end-wall_st
1529 wall_time = wall_end-wall_st
1525 cpu_user = end[0]-st[0]
1530 cpu_user = end[0]-st[0]
1526 cpu_sys = end[1]-st[1]
1531 cpu_sys = end[1]-st[1]
1527 cpu_tot = cpu_user+cpu_sys
1532 cpu_tot = cpu_user+cpu_sys
1528 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1533 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1529 (cpu_user,cpu_sys,cpu_tot)
1534 (cpu_user,cpu_sys,cpu_tot)
1530 print "Wall time: %.2f" % wall_time
1535 print "Wall time: %.2f" % wall_time
1531 return out
1536 return out
1532
1537
1533 def magic_macro(self,parameter_s = ''):
1538 def magic_macro(self,parameter_s = ''):
1534 """Define a set of input lines as a macro for future re-execution.
1539 """Define a set of input lines as a macro for future re-execution.
1535
1540
1536 Usage:\\
1541 Usage:\\
1537 %macro name n1:n2 n3:n4 ... n5 .. n6 ...
1542 %macro name n1:n2 n3:n4 ... n5 .. n6 ...
1538
1543
1539 This will define a global variable called `name` which is a string
1544 This will define a global variable called `name` which is a string
1540 made of joining the slices and lines you specify (n1,n2,... numbers
1545 made of joining the slices and lines you specify (n1,n2,... numbers
1541 above) from your input history into a single string. This variable
1546 above) from your input history into a single string. This variable
1542 acts like an automatic function which re-executes those lines as if
1547 acts like an automatic function which re-executes those lines as if
1543 you had typed them. You just type 'name' at the prompt and the code
1548 you had typed them. You just type 'name' at the prompt and the code
1544 executes.
1549 executes.
1545
1550
1546 Note that the slices use the standard Python slicing notation (5:8
1551 Note that the slices use the standard Python slicing notation (5:8
1547 means include lines numbered 5,6,7).
1552 means include lines numbered 5,6,7).
1548
1553
1549 For example, if your history contains (%hist prints it):
1554 For example, if your history contains (%hist prints it):
1550
1555
1551 44: x=1\\
1556 44: x=1\\
1552 45: y=3\\
1557 45: y=3\\
1553 46: z=x+y\\
1558 46: z=x+y\\
1554 47: print x\\
1559 47: print x\\
1555 48: a=5\\
1560 48: a=5\\
1556 49: print 'x',x,'y',y\\
1561 49: print 'x',x,'y',y\\
1557
1562
1558 you can create a macro with lines 44 through 47 (included) and line 49
1563 you can create a macro with lines 44 through 47 (included) and line 49
1559 called my_macro with:
1564 called my_macro with:
1560
1565
1561 In [51]: %macro my_macro 44:48 49
1566 In [51]: %macro my_macro 44:48 49
1562
1567
1563 Now, typing `my_macro` (without quotes) will re-execute all this code
1568 Now, typing `my_macro` (without quotes) will re-execute all this code
1564 in one pass.
1569 in one pass.
1565
1570
1566 You don't need to give the line-numbers in order, and any given line
1571 You don't need to give the line-numbers in order, and any given line
1567 number can appear multiple times. You can assemble macros with any
1572 number can appear multiple times. You can assemble macros with any
1568 lines from your input history in any order.
1573 lines from your input history in any order.
1569
1574
1570 The macro is a simple object which holds its value in an attribute,
1575 The macro is a simple object which holds its value in an attribute,
1571 but IPython's display system checks for macros and executes them as
1576 but IPython's display system checks for macros and executes them as
1572 code instead of printing them when you type their name.
1577 code instead of printing them when you type their name.
1573
1578
1574 You can view a macro's contents by explicitly printing it with:
1579 You can view a macro's contents by explicitly printing it with:
1575
1580
1576 'print macro_name'.
1581 'print macro_name'.
1577
1582
1578 For one-off cases which DON'T contain magic function calls in them you
1583 For one-off cases which DON'T contain magic function calls in them you
1579 can obtain similar results by explicitly executing slices from your
1584 can obtain similar results by explicitly executing slices from your
1580 input history with:
1585 input history with:
1581
1586
1582 In [60]: exec In[44:48]+In[49]"""
1587 In [60]: exec In[44:48]+In[49]"""
1583
1588
1584 args = parameter_s.split()
1589 args = parameter_s.split()
1585 name,ranges = args[0], args[1:]
1590 name,ranges = args[0], args[1:]
1586 #print 'rng',ranges # dbg
1591 #print 'rng',ranges # dbg
1587 lines = self.extract_input_slices(ranges)
1592 lines = self.extract_input_slices(ranges)
1588 macro = Macro(lines)
1593 macro = Macro(lines)
1589 self.shell.user_ns.update({name:macro})
1594 self.shell.user_ns.update({name:macro})
1590 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
1595 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
1591 print 'Macro contents:'
1596 print 'Macro contents:'
1592 print macro,
1597 print macro,
1593
1598
1594 def magic_save(self,parameter_s = ''):
1599 def magic_save(self,parameter_s = ''):
1595 """Save a set of lines to a given filename.
1600 """Save a set of lines to a given filename.
1596
1601
1597 Usage:\\
1602 Usage:\\
1598 %save filename n1:n2 n3:n4 ... n5 .. n6 ...
1603 %save filename n1:n2 n3:n4 ... n5 .. n6 ...
1599
1604
1600 This function uses the same syntax as %macro for line extraction, but
1605 This function uses the same syntax as %macro for line extraction, but
1601 instead of creating a macro it saves the resulting string to the
1606 instead of creating a macro it saves the resulting string to the
1602 filename you specify.
1607 filename you specify.
1603
1608
1604 It adds a '.py' extension to the file if you don't do so yourself, and
1609 It adds a '.py' extension to the file if you don't do so yourself, and
1605 it asks for confirmation before overwriting existing files."""
1610 it asks for confirmation before overwriting existing files."""
1606
1611
1607 args = parameter_s.split()
1612 args = parameter_s.split()
1608 fname,ranges = args[0], args[1:]
1613 fname,ranges = args[0], args[1:]
1609 if not fname.endswith('.py'):
1614 if not fname.endswith('.py'):
1610 fname += '.py'
1615 fname += '.py'
1611 if os.path.isfile(fname):
1616 if os.path.isfile(fname):
1612 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
1617 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
1613 if ans.lower() not in ['y','yes']:
1618 if ans.lower() not in ['y','yes']:
1614 print 'Operation cancelled.'
1619 print 'Operation cancelled.'
1615 return
1620 return
1616 cmds = ''.join(self.extract_input_slices(ranges))
1621 cmds = ''.join(self.extract_input_slices(ranges))
1617 f = file(fname,'w')
1622 f = file(fname,'w')
1618 f.write(cmds)
1623 f.write(cmds)
1619 f.close()
1624 f.close()
1620 print 'The following commands were written to file `%s`:' % fname
1625 print 'The following commands were written to file `%s`:' % fname
1621 print cmds
1626 print cmds
1622
1627
1623 def magic_ed(self,parameter_s = ''):
1628 def magic_ed(self,parameter_s = ''):
1624 """Alias to %edit."""
1629 """Alias to %edit."""
1625 return self.magic_edit(parameter_s)
1630 return self.magic_edit(parameter_s)
1626
1631
1627 def magic_edit(self,parameter_s = '',last_call=['','']):
1632 def magic_edit(self,parameter_s = '',last_call=['','']):
1628 """Bring up an editor and execute the resulting code.
1633 """Bring up an editor and execute the resulting code.
1629
1634
1630 Usage:
1635 Usage:
1631 %edit [options] [args]
1636 %edit [options] [args]
1632
1637
1633 %edit runs IPython's editor hook. The default version of this hook is
1638 %edit runs IPython's editor hook. The default version of this hook is
1634 set to call the __IPYTHON__.rc.editor command. This is read from your
1639 set to call the __IPYTHON__.rc.editor command. This is read from your
1635 environment variable $EDITOR. If this isn't found, it will default to
1640 environment variable $EDITOR. If this isn't found, it will default to
1636 vi under Linux/Unix and to notepad under Windows. See the end of this
1641 vi under Linux/Unix and to notepad under Windows. See the end of this
1637 docstring for how to change the editor hook.
1642 docstring for how to change the editor hook.
1638
1643
1639 You can also set the value of this editor via the command line option
1644 You can also set the value of this editor via the command line option
1640 '-editor' or in your ipythonrc file. This is useful if you wish to use
1645 '-editor' or in your ipythonrc file. This is useful if you wish to use
1641 specifically for IPython an editor different from your typical default
1646 specifically for IPython an editor different from your typical default
1642 (and for Windows users who typically don't set environment variables).
1647 (and for Windows users who typically don't set environment variables).
1643
1648
1644 This command allows you to conveniently edit multi-line code right in
1649 This command allows you to conveniently edit multi-line code right in
1645 your IPython session.
1650 your IPython session.
1646
1651
1647 If called without arguments, %edit opens up an empty editor with a
1652 If called without arguments, %edit opens up an empty editor with a
1648 temporary file and will execute the contents of this file when you
1653 temporary file and will execute the contents of this file when you
1649 close it (don't forget to save it!).
1654 close it (don't forget to save it!).
1650
1655
1651 Options:
1656 Options:
1652
1657
1653 -p: this will call the editor with the same data as the previous time
1658 -p: this will call the editor with the same data as the previous time
1654 it was used, regardless of how long ago (in your current session) it
1659 it was used, regardless of how long ago (in your current session) it
1655 was.
1660 was.
1656
1661
1657 -x: do not execute the edited code immediately upon exit. This is
1662 -x: do not execute the edited code immediately upon exit. This is
1658 mainly useful if you are editing programs which need to be called with
1663 mainly useful if you are editing programs which need to be called with
1659 command line arguments, which you can then do using %run.
1664 command line arguments, which you can then do using %run.
1660
1665
1661 Arguments:
1666 Arguments:
1662
1667
1663 If arguments are given, the following possibilites exist:
1668 If arguments are given, the following possibilites exist:
1664
1669
1665 - The arguments are numbers or pairs of colon-separated numbers (like
1670 - The arguments are numbers or pairs of colon-separated numbers (like
1666 1 4:8 9). These are interpreted as lines of previous input to be
1671 1 4:8 9). These are interpreted as lines of previous input to be
1667 loaded into the editor. The syntax is the same of the %macro command.
1672 loaded into the editor. The syntax is the same of the %macro command.
1668
1673
1669 - If the argument doesn't start with a number, it is evaluated as a
1674 - If the argument doesn't start with a number, it is evaluated as a
1670 variable and its contents loaded into the editor. You can thus edit
1675 variable and its contents loaded into the editor. You can thus edit
1671 any string which contains python code (including the result of
1676 any string which contains python code (including the result of
1672 previous edits).
1677 previous edits).
1673
1678
1674 - If the argument is the name of an object (other than a string),
1679 - If the argument is the name of an object (other than a string),
1675 IPython will try to locate the file where it was defined and open the
1680 IPython will try to locate the file where it was defined and open the
1676 editor at the point where it is defined. You can use `%edit function`
1681 editor at the point where it is defined. You can use `%edit function`
1677 to load an editor exactly at the point where 'function' is defined,
1682 to load an editor exactly at the point where 'function' is defined,
1678 edit it and have the file be executed automatically.
1683 edit it and have the file be executed automatically.
1679
1684
1680 Note: opening at an exact line is only supported under Unix, and some
1685 Note: opening at an exact line is only supported under Unix, and some
1681 editors (like kedit and gedit up to Gnome 2.8) do not understand the
1686 editors (like kedit and gedit up to Gnome 2.8) do not understand the
1682 '+NUMBER' parameter necessary for this feature. Good editors like
1687 '+NUMBER' parameter necessary for this feature. Good editors like
1683 (X)Emacs, vi, jed, pico and joe all do.
1688 (X)Emacs, vi, jed, pico and joe all do.
1684
1689
1685 - If the argument is not found as a variable, IPython will look for a
1690 - If the argument is not found as a variable, IPython will look for a
1686 file with that name (adding .py if necessary) and load it into the
1691 file with that name (adding .py if necessary) and load it into the
1687 editor. It will execute its contents with execfile() when you exit,
1692 editor. It will execute its contents with execfile() when you exit,
1688 loading any code in the file into your interactive namespace.
1693 loading any code in the file into your interactive namespace.
1689
1694
1690 After executing your code, %edit will return as output the code you
1695 After executing your code, %edit will return as output the code you
1691 typed in the editor (except when it was an existing file). This way
1696 typed in the editor (except when it was an existing file). This way
1692 you can reload the code in further invocations of %edit as a variable,
1697 you can reload the code in further invocations of %edit as a variable,
1693 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
1698 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
1694 the output.
1699 the output.
1695
1700
1696 Note that %edit is also available through the alias %ed.
1701 Note that %edit is also available through the alias %ed.
1697
1702
1698 This is an example of creating a simple function inside the editor and
1703 This is an example of creating a simple function inside the editor and
1699 then modifying it. First, start up the editor:
1704 then modifying it. First, start up the editor:
1700
1705
1701 In [1]: ed\\
1706 In [1]: ed\\
1702 Editing... done. Executing edited code...\\
1707 Editing... done. Executing edited code...\\
1703 Out[1]: 'def foo():\\n print "foo() was defined in an editing session"\\n'
1708 Out[1]: 'def foo():\\n print "foo() was defined in an editing session"\\n'
1704
1709
1705 We can then call the function foo():
1710 We can then call the function foo():
1706
1711
1707 In [2]: foo()\\
1712 In [2]: foo()\\
1708 foo() was defined in an editing session
1713 foo() was defined in an editing session
1709
1714
1710 Now we edit foo. IPython automatically loads the editor with the
1715 Now we edit foo. IPython automatically loads the editor with the
1711 (temporary) file where foo() was previously defined:
1716 (temporary) file where foo() was previously defined:
1712
1717
1713 In [3]: ed foo\\
1718 In [3]: ed foo\\
1714 Editing... done. Executing edited code...
1719 Editing... done. Executing edited code...
1715
1720
1716 And if we call foo() again we get the modified version:
1721 And if we call foo() again we get the modified version:
1717
1722
1718 In [4]: foo()\\
1723 In [4]: foo()\\
1719 foo() has now been changed!
1724 foo() has now been changed!
1720
1725
1721 Here is an example of how to edit a code snippet successive
1726 Here is an example of how to edit a code snippet successive
1722 times. First we call the editor:
1727 times. First we call the editor:
1723
1728
1724 In [8]: ed\\
1729 In [8]: ed\\
1725 Editing... done. Executing edited code...\\
1730 Editing... done. Executing edited code...\\
1726 hello\\
1731 hello\\
1727 Out[8]: "print 'hello'\\n"
1732 Out[8]: "print 'hello'\\n"
1728
1733
1729 Now we call it again with the previous output (stored in _):
1734 Now we call it again with the previous output (stored in _):
1730
1735
1731 In [9]: ed _\\
1736 In [9]: ed _\\
1732 Editing... done. Executing edited code...\\
1737 Editing... done. Executing edited code...\\
1733 hello world\\
1738 hello world\\
1734 Out[9]: "print 'hello world'\\n"
1739 Out[9]: "print 'hello world'\\n"
1735
1740
1736 Now we call it with the output #8 (stored in _8, also as Out[8]):
1741 Now we call it with the output #8 (stored in _8, also as Out[8]):
1737
1742
1738 In [10]: ed _8\\
1743 In [10]: ed _8\\
1739 Editing... done. Executing edited code...\\
1744 Editing... done. Executing edited code...\\
1740 hello again\\
1745 hello again\\
1741 Out[10]: "print 'hello again'\\n"
1746 Out[10]: "print 'hello again'\\n"
1742
1747
1743
1748
1744 Changing the default editor hook:
1749 Changing the default editor hook:
1745
1750
1746 If you wish to write your own editor hook, you can put it in a
1751 If you wish to write your own editor hook, you can put it in a
1747 configuration file which you load at startup time. The default hook
1752 configuration file which you load at startup time. The default hook
1748 is defined in the IPython.hooks module, and you can use that as a
1753 is defined in the IPython.hooks module, and you can use that as a
1749 starting example for further modifications. That file also has
1754 starting example for further modifications. That file also has
1750 general instructions on how to set a new hook for use once you've
1755 general instructions on how to set a new hook for use once you've
1751 defined it."""
1756 defined it."""
1752
1757
1753 # FIXME: This function has become a convoluted mess. It needs a
1758 # FIXME: This function has become a convoluted mess. It needs a
1754 # ground-up rewrite with clean, simple logic.
1759 # ground-up rewrite with clean, simple logic.
1755
1760
1756 def make_filename(arg):
1761 def make_filename(arg):
1757 "Make a filename from the given args"
1762 "Make a filename from the given args"
1758 try:
1763 try:
1759 filename = get_py_filename(arg)
1764 filename = get_py_filename(arg)
1760 except IOError:
1765 except IOError:
1761 if args.endswith('.py'):
1766 if args.endswith('.py'):
1762 filename = arg
1767 filename = arg
1763 else:
1768 else:
1764 filename = None
1769 filename = None
1765 return filename
1770 return filename
1766
1771
1767 # custom exceptions
1772 # custom exceptions
1768 class DataIsObject(Exception): pass
1773 class DataIsObject(Exception): pass
1769
1774
1770 opts,args = self.parse_options(parameter_s,'px')
1775 opts,args = self.parse_options(parameter_s,'px')
1771
1776
1772 # Default line number value
1777 # Default line number value
1773 lineno = None
1778 lineno = None
1774 if opts.has_key('p'):
1779 if opts.has_key('p'):
1775 args = '_%s' % last_call[0]
1780 args = '_%s' % last_call[0]
1776 if not self.shell.user_ns.has_key(args):
1781 if not self.shell.user_ns.has_key(args):
1777 args = last_call[1]
1782 args = last_call[1]
1778
1783
1779 # use last_call to remember the state of the previous call, but don't
1784 # use last_call to remember the state of the previous call, but don't
1780 # let it be clobbered by successive '-p' calls.
1785 # let it be clobbered by successive '-p' calls.
1781 try:
1786 try:
1782 last_call[0] = self.shell.outputcache.prompt_count
1787 last_call[0] = self.shell.outputcache.prompt_count
1783 if not opts.has_key('p'):
1788 if not opts.has_key('p'):
1784 last_call[1] = parameter_s
1789 last_call[1] = parameter_s
1785 except:
1790 except:
1786 pass
1791 pass
1787
1792
1788 # by default this is done with temp files, except when the given
1793 # by default this is done with temp files, except when the given
1789 # arg is a filename
1794 # arg is a filename
1790 use_temp = 1
1795 use_temp = 1
1791
1796
1792 if re.match(r'\d',args):
1797 if re.match(r'\d',args):
1793 # Mode where user specifies ranges of lines, like in %macro.
1798 # Mode where user specifies ranges of lines, like in %macro.
1794 # This means that you can't edit files whose names begin with
1799 # This means that you can't edit files whose names begin with
1795 # numbers this way. Tough.
1800 # numbers this way. Tough.
1796 ranges = args.split()
1801 ranges = args.split()
1797 data = ''.join(self.extract_input_slices(ranges))
1802 data = ''.join(self.extract_input_slices(ranges))
1798 elif args.endswith('.py'):
1803 elif args.endswith('.py'):
1799 filename = make_filename(args)
1804 filename = make_filename(args)
1800 data = ''
1805 data = ''
1801 use_temp = 0
1806 use_temp = 0
1802 elif args:
1807 elif args:
1803 try:
1808 try:
1804 # Load the parameter given as a variable. If not a string,
1809 # Load the parameter given as a variable. If not a string,
1805 # process it as an object instead (below)
1810 # process it as an object instead (below)
1806
1811
1807 #print '*** args',args,'type',type(args) # dbg
1812 #print '*** args',args,'type',type(args) # dbg
1808 data = eval(args,self.shell.user_ns)
1813 data = eval(args,self.shell.user_ns)
1809 if not type(data) in StringTypes:
1814 if not type(data) in StringTypes:
1810 raise DataIsObject
1815 raise DataIsObject
1811 except (NameError,SyntaxError):
1816 except (NameError,SyntaxError):
1812 # given argument is not a variable, try as a filename
1817 # given argument is not a variable, try as a filename
1813 filename = make_filename(args)
1818 filename = make_filename(args)
1814 if filename is None:
1819 if filename is None:
1815 warn("Argument given (%s) can't be found as a variable "
1820 warn("Argument given (%s) can't be found as a variable "
1816 "or as a filename." % args)
1821 "or as a filename." % args)
1817 return
1822 return
1818 data = ''
1823 data = ''
1819 use_temp = 0
1824 use_temp = 0
1820 except DataIsObject:
1825 except DataIsObject:
1821 # For objects, try to edit the file where they are defined
1826 # For objects, try to edit the file where they are defined
1822 try:
1827 try:
1823 filename = inspect.getabsfile(data)
1828 filename = inspect.getabsfile(data)
1824 datafile = 1
1829 datafile = 1
1825 except TypeError:
1830 except TypeError:
1826 filename = make_filename(args)
1831 filename = make_filename(args)
1827 datafile = 1
1832 datafile = 1
1828 warn('Could not find file where `%s` is defined.\n'
1833 warn('Could not find file where `%s` is defined.\n'
1829 'Opening a file named `%s`' % (args,filename))
1834 'Opening a file named `%s`' % (args,filename))
1830 # Now, make sure we can actually read the source (if it was in
1835 # Now, make sure we can actually read the source (if it was in
1831 # a temp file it's gone by now).
1836 # a temp file it's gone by now).
1832 if datafile:
1837 if datafile:
1833 try:
1838 try:
1834 lineno = inspect.getsourcelines(data)[1]
1839 lineno = inspect.getsourcelines(data)[1]
1835 except IOError:
1840 except IOError:
1836 filename = make_filename(args)
1841 filename = make_filename(args)
1837 if filename is None:
1842 if filename is None:
1838 warn('The file `%s` where `%s` was defined cannot '
1843 warn('The file `%s` where `%s` was defined cannot '
1839 'be read.' % (filename,data))
1844 'be read.' % (filename,data))
1840 return
1845 return
1841 use_temp = 0
1846 use_temp = 0
1842 else:
1847 else:
1843 data = ''
1848 data = ''
1844
1849
1845 if use_temp:
1850 if use_temp:
1846 filename = tempfile.mktemp('.py')
1851 filename = tempfile.mktemp('.py')
1847 self.shell.tempfiles.append(filename)
1852 self.shell.tempfiles.append(filename)
1848
1853
1849 if data and use_temp:
1854 if data and use_temp:
1850 tmp_file = open(filename,'w')
1855 tmp_file = open(filename,'w')
1851 tmp_file.write(data)
1856 tmp_file.write(data)
1852 tmp_file.close()
1857 tmp_file.close()
1853
1858
1854 # do actual editing here
1859 # do actual editing here
1855 print 'Editing...',
1860 print 'Editing...',
1856 sys.stdout.flush()
1861 sys.stdout.flush()
1857 self.shell.hooks.editor(filename,lineno)
1862 self.shell.hooks.editor(filename,lineno)
1858 if opts.has_key('x'): # -x prevents actual execution
1863 if opts.has_key('x'): # -x prevents actual execution
1859 print
1864 print
1860 else:
1865 else:
1861 print 'done. Executing edited code...'
1866 print 'done. Executing edited code...'
1862 try:
1867 try:
1863 self.shell.safe_execfile(filename,self.shell.user_ns)
1868 self.shell.safe_execfile(filename,self.shell.user_ns)
1864 except IOError,msg:
1869 except IOError,msg:
1865 if msg.filename == filename:
1870 if msg.filename == filename:
1866 warn('File not found. Did you forget to save?')
1871 warn('File not found. Did you forget to save?')
1867 return
1872 return
1868 else:
1873 else:
1869 self.shell.showtraceback()
1874 self.shell.showtraceback()
1870 except:
1875 except:
1871 self.shell.showtraceback()
1876 self.shell.showtraceback()
1872 if use_temp:
1877 if use_temp:
1873 contents = open(filename).read()
1878 contents = open(filename).read()
1874 return contents
1879 return contents
1875
1880
1876 def magic_xmode(self,parameter_s = ''):
1881 def magic_xmode(self,parameter_s = ''):
1877 """Switch modes for the exception handlers.
1882 """Switch modes for the exception handlers.
1878
1883
1879 Valid modes: Plain, Context and Verbose.
1884 Valid modes: Plain, Context and Verbose.
1880
1885
1881 If called without arguments, acts as a toggle."""
1886 If called without arguments, acts as a toggle."""
1882
1887
1883 def xmode_switch_err(name):
1888 def xmode_switch_err(name):
1884 warn('Error changing %s exception modes.\n%s' %
1889 warn('Error changing %s exception modes.\n%s' %
1885 (name,sys.exc_info()[1]))
1890 (name,sys.exc_info()[1]))
1886
1891
1887 shell = self.shell
1892 shell = self.shell
1888 new_mode = parameter_s.strip().capitalize()
1893 new_mode = parameter_s.strip().capitalize()
1889 try:
1894 try:
1890 shell.InteractiveTB.set_mode(mode=new_mode)
1895 shell.InteractiveTB.set_mode(mode=new_mode)
1891 print 'Exception reporting mode:',shell.InteractiveTB.mode
1896 print 'Exception reporting mode:',shell.InteractiveTB.mode
1892 except:
1897 except:
1893 xmode_switch_err('user')
1898 xmode_switch_err('user')
1894
1899
1895 # threaded shells use a special handler in sys.excepthook
1900 # threaded shells use a special handler in sys.excepthook
1896 if shell.isthreaded:
1901 if shell.isthreaded:
1897 try:
1902 try:
1898 shell.sys_excepthook.set_mode(mode=new_mode)
1903 shell.sys_excepthook.set_mode(mode=new_mode)
1899 except:
1904 except:
1900 xmode_switch_err('threaded')
1905 xmode_switch_err('threaded')
1901
1906
1902 def magic_colors(self,parameter_s = ''):
1907 def magic_colors(self,parameter_s = ''):
1903 """Switch color scheme for prompts, info system and exception handlers.
1908 """Switch color scheme for prompts, info system and exception handlers.
1904
1909
1905 Currently implemented schemes: NoColor, Linux, LightBG.
1910 Currently implemented schemes: NoColor, Linux, LightBG.
1906
1911
1907 Color scheme names are not case-sensitive."""
1912 Color scheme names are not case-sensitive."""
1908
1913
1909 def color_switch_err(name):
1914 def color_switch_err(name):
1910 warn('Error changing %s color schemes.\n%s' %
1915 warn('Error changing %s color schemes.\n%s' %
1911 (name,sys.exc_info()[1]))
1916 (name,sys.exc_info()[1]))
1912
1917
1913
1918
1914 new_scheme = parameter_s.strip()
1919 new_scheme = parameter_s.strip()
1915 if not new_scheme:
1920 if not new_scheme:
1916 print 'You must specify a color scheme.'
1921 print 'You must specify a color scheme.'
1917 return
1922 return
1918 # Under Windows, check for Gary Bishop's readline, which is necessary
1923 # Under Windows, check for Gary Bishop's readline, which is necessary
1919 # for ANSI coloring
1924 # for ANSI coloring
1920 if os.name in ['nt','dos']:
1925 if os.name in ['nt','dos']:
1921 try:
1926 try:
1922 import readline
1927 import readline
1923 except ImportError:
1928 except ImportError:
1924 has_readline = 0
1929 has_readline = 0
1925 else:
1930 else:
1926 try:
1931 try:
1927 readline.GetOutputFile()
1932 readline.GetOutputFile()
1928 except AttributeError:
1933 except AttributeError:
1929 has_readline = 0
1934 has_readline = 0
1930 else:
1935 else:
1931 has_readline = 1
1936 has_readline = 1
1932 if not has_readline:
1937 if not has_readline:
1933 msg = """\
1938 msg = """\
1934 Proper color support under MS Windows requires Gary Bishop's readline library.
1939 Proper color support under MS Windows requires Gary Bishop's readline library.
1935 You can find it at:
1940 You can find it at:
1936 http://sourceforge.net/projects/uncpythontools
1941 http://sourceforge.net/projects/uncpythontools
1937 Gary's readline needs the ctypes module, from:
1942 Gary's readline needs the ctypes module, from:
1938 http://starship.python.net/crew/theller/ctypes
1943 http://starship.python.net/crew/theller/ctypes
1939
1944
1940 Defaulting color scheme to 'NoColor'"""
1945 Defaulting color scheme to 'NoColor'"""
1941 new_scheme = 'NoColor'
1946 new_scheme = 'NoColor'
1942 warn(msg)
1947 warn(msg)
1943 # local shortcut
1948 # local shortcut
1944 shell = self.shell
1949 shell = self.shell
1945
1950
1946 # Set prompt colors
1951 # Set prompt colors
1947 try:
1952 try:
1948 shell.outputcache.set_colors(new_scheme)
1953 shell.outputcache.set_colors(new_scheme)
1949 except:
1954 except:
1950 color_switch_err('prompt')
1955 color_switch_err('prompt')
1951 else:
1956 else:
1952 shell.rc.colors = \
1957 shell.rc.colors = \
1953 shell.outputcache.color_table.active_scheme_name
1958 shell.outputcache.color_table.active_scheme_name
1954 # Set exception colors
1959 # Set exception colors
1955 try:
1960 try:
1956 shell.InteractiveTB.set_colors(scheme = new_scheme)
1961 shell.InteractiveTB.set_colors(scheme = new_scheme)
1957 shell.SyntaxTB.set_colors(scheme = new_scheme)
1962 shell.SyntaxTB.set_colors(scheme = new_scheme)
1958 except:
1963 except:
1959 color_switch_err('exception')
1964 color_switch_err('exception')
1960
1965
1961 # threaded shells use a verbose traceback in sys.excepthook
1966 # threaded shells use a verbose traceback in sys.excepthook
1962 if shell.isthreaded:
1967 if shell.isthreaded:
1963 try:
1968 try:
1964 shell.sys_excepthook.set_colors(scheme=new_scheme)
1969 shell.sys_excepthook.set_colors(scheme=new_scheme)
1965 except:
1970 except:
1966 color_switch_err('system exception handler')
1971 color_switch_err('system exception handler')
1967
1972
1968 # Set info (for 'object?') colors
1973 # Set info (for 'object?') colors
1969 if shell.rc.color_info:
1974 if shell.rc.color_info:
1970 try:
1975 try:
1971 shell.inspector.set_active_scheme(new_scheme)
1976 shell.inspector.set_active_scheme(new_scheme)
1972 except:
1977 except:
1973 color_switch_err('object inspector')
1978 color_switch_err('object inspector')
1974 else:
1979 else:
1975 shell.inspector.set_active_scheme('NoColor')
1980 shell.inspector.set_active_scheme('NoColor')
1976
1981
1977 def magic_color_info(self,parameter_s = ''):
1982 def magic_color_info(self,parameter_s = ''):
1978 """Toggle color_info.
1983 """Toggle color_info.
1979
1984
1980 The color_info configuration parameter controls whether colors are
1985 The color_info configuration parameter controls whether colors are
1981 used for displaying object details (by things like %psource, %pfile or
1986 used for displaying object details (by things like %psource, %pfile or
1982 the '?' system). This function toggles this value with each call.
1987 the '?' system). This function toggles this value with each call.
1983
1988
1984 Note that unless you have a fairly recent pager (less works better
1989 Note that unless you have a fairly recent pager (less works better
1985 than more) in your system, using colored object information displays
1990 than more) in your system, using colored object information displays
1986 will not work properly. Test it and see."""
1991 will not work properly. Test it and see."""
1987
1992
1988 self.shell.rc.color_info = 1 - self.shell.rc.color_info
1993 self.shell.rc.color_info = 1 - self.shell.rc.color_info
1989 self.magic_colors(self.shell.rc.colors)
1994 self.magic_colors(self.shell.rc.colors)
1990 print 'Object introspection functions have now coloring:',
1995 print 'Object introspection functions have now coloring:',
1991 print ['OFF','ON'][self.shell.rc.color_info]
1996 print ['OFF','ON'][self.shell.rc.color_info]
1992
1997
1993 def magic_Pprint(self, parameter_s=''):
1998 def magic_Pprint(self, parameter_s=''):
1994 """Toggle pretty printing on/off."""
1999 """Toggle pretty printing on/off."""
1995
2000
1996 self.shell.outputcache.Pprint = 1 - self.shell.outputcache.Pprint
2001 self.shell.outputcache.Pprint = 1 - self.shell.outputcache.Pprint
1997 print 'Pretty printing has been turned', \
2002 print 'Pretty printing has been turned', \
1998 ['OFF','ON'][self.shell.outputcache.Pprint]
2003 ['OFF','ON'][self.shell.outputcache.Pprint]
1999
2004
2000 def magic_exit(self, parameter_s=''):
2005 def magic_exit(self, parameter_s=''):
2001 """Exit IPython, confirming if configured to do so.
2006 """Exit IPython, confirming if configured to do so.
2002
2007
2003 You can configure whether IPython asks for confirmation upon exit by
2008 You can configure whether IPython asks for confirmation upon exit by
2004 setting the confirm_exit flag in the ipythonrc file."""
2009 setting the confirm_exit flag in the ipythonrc file."""
2005
2010
2006 self.shell.exit()
2011 self.shell.exit()
2007
2012
2008 def magic_quit(self, parameter_s=''):
2013 def magic_quit(self, parameter_s=''):
2009 """Exit IPython, confirming if configured to do so (like %exit)"""
2014 """Exit IPython, confirming if configured to do so (like %exit)"""
2010
2015
2011 self.shell.exit()
2016 self.shell.exit()
2012
2017
2013 def magic_Exit(self, parameter_s=''):
2018 def magic_Exit(self, parameter_s=''):
2014 """Exit IPython without confirmation."""
2019 """Exit IPython without confirmation."""
2015
2020
2016 self.shell.exit_now = True
2021 self.shell.exit_now = True
2017
2022
2018 def magic_Quit(self, parameter_s=''):
2023 def magic_Quit(self, parameter_s=''):
2019 """Exit IPython without confirmation (like %Exit)."""
2024 """Exit IPython without confirmation (like %Exit)."""
2020
2025
2021 self.shell.exit_now = True
2026 self.shell.exit_now = True
2022
2027
2023 #......................................................................
2028 #......................................................................
2024 # Functions to implement unix shell-type things
2029 # Functions to implement unix shell-type things
2025
2030
2026 def magic_alias(self, parameter_s = ''):
2031 def magic_alias(self, parameter_s = ''):
2027 """Define an alias for a system command.
2032 """Define an alias for a system command.
2028
2033
2029 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2034 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2030
2035
2031 Then, typing 'alias_name params' will execute the system command 'cmd
2036 Then, typing 'alias_name params' will execute the system command 'cmd
2032 params' (from your underlying operating system).
2037 params' (from your underlying operating system).
2033
2038
2034 Aliases have lower precedence than magic functions and Python normal
2039 Aliases have lower precedence than magic functions and Python normal
2035 variables, so if 'foo' is both a Python variable and an alias, the
2040 variables, so if 'foo' is both a Python variable and an alias, the
2036 alias can not be executed until 'del foo' removes the Python variable.
2041 alias can not be executed until 'del foo' removes the Python variable.
2037
2042
2038 You can use the %l specifier in an alias definition to represent the
2043 You can use the %l specifier in an alias definition to represent the
2039 whole line when the alias is called. For example:
2044 whole line when the alias is called. For example:
2040
2045
2041 In [2]: alias all echo "Input in brackets: <%l>"\\
2046 In [2]: alias all echo "Input in brackets: <%l>"\\
2042 In [3]: all hello world\\
2047 In [3]: all hello world\\
2043 Input in brackets: <hello world>
2048 Input in brackets: <hello world>
2044
2049
2045 You can also define aliases with parameters using %s specifiers (one
2050 You can also define aliases with parameters using %s specifiers (one
2046 per parameter):
2051 per parameter):
2047
2052
2048 In [1]: alias parts echo first %s second %s\\
2053 In [1]: alias parts echo first %s second %s\\
2049 In [2]: %parts A B\\
2054 In [2]: %parts A B\\
2050 first A second B\\
2055 first A second B\\
2051 In [3]: %parts A\\
2056 In [3]: %parts A\\
2052 Incorrect number of arguments: 2 expected.\\
2057 Incorrect number of arguments: 2 expected.\\
2053 parts is an alias to: 'echo first %s second %s'
2058 parts is an alias to: 'echo first %s second %s'
2054
2059
2055 Note that %l and %s are mutually exclusive. You can only use one or
2060 Note that %l and %s are mutually exclusive. You can only use one or
2056 the other in your aliases.
2061 the other in your aliases.
2057
2062
2058 Aliases expand Python variables just like system calls using ! or !!
2063 Aliases expand Python variables just like system calls using ! or !!
2059 do: all expressions prefixed with '$' get expanded. For details of
2064 do: all expressions prefixed with '$' get expanded. For details of
2060 the semantic rules, see PEP-215:
2065 the semantic rules, see PEP-215:
2061 http://www.python.org/peps/pep-0215.html. This is the library used by
2066 http://www.python.org/peps/pep-0215.html. This is the library used by
2062 IPython for variable expansion. If you want to access a true shell
2067 IPython for variable expansion. If you want to access a true shell
2063 variable, an extra $ is necessary to prevent its expansion by IPython:
2068 variable, an extra $ is necessary to prevent its expansion by IPython:
2064
2069
2065 In [6]: alias show echo\\
2070 In [6]: alias show echo\\
2066 In [7]: PATH='A Python string'\\
2071 In [7]: PATH='A Python string'\\
2067 In [8]: show $PATH\\
2072 In [8]: show $PATH\\
2068 A Python string\\
2073 A Python string\\
2069 In [9]: show $$PATH\\
2074 In [9]: show $$PATH\\
2070 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2075 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2071
2076
2072 You can use the alias facility to acess all of $PATH. See the %rehash
2077 You can use the alias facility to acess all of $PATH. See the %rehash
2073 and %rehashx functions, which automatically create aliases for the
2078 and %rehashx functions, which automatically create aliases for the
2074 contents of your $PATH.
2079 contents of your $PATH.
2075
2080
2076 If called with no parameters, %alias prints the current alias table."""
2081 If called with no parameters, %alias prints the current alias table."""
2077
2082
2078 par = parameter_s.strip()
2083 par = parameter_s.strip()
2079 if not par:
2084 if not par:
2080 if self.shell.rc.automagic:
2085 if self.shell.rc.automagic:
2081 prechar = ''
2086 prechar = ''
2082 else:
2087 else:
2083 prechar = self.shell.ESC_MAGIC
2088 prechar = self.shell.ESC_MAGIC
2084 print 'Alias\t\tSystem Command\n'+'-'*30
2089 print 'Alias\t\tSystem Command\n'+'-'*30
2085 atab = self.shell.alias_table
2090 atab = self.shell.alias_table
2086 aliases = atab.keys()
2091 aliases = atab.keys()
2087 aliases.sort()
2092 aliases.sort()
2088 for alias in aliases:
2093 for alias in aliases:
2089 print prechar+alias+'\t\t'+atab[alias][1]
2094 print prechar+alias+'\t\t'+atab[alias][1]
2090 print '-'*30+'\nTotal number of aliases:',len(aliases)
2095 print '-'*30+'\nTotal number of aliases:',len(aliases)
2091 return
2096 return
2092 try:
2097 try:
2093 alias,cmd = par.split(None,1)
2098 alias,cmd = par.split(None,1)
2094 except:
2099 except:
2095 print OInspect.getdoc(self.magic_alias)
2100 print OInspect.getdoc(self.magic_alias)
2096 else:
2101 else:
2097 nargs = cmd.count('%s')
2102 nargs = cmd.count('%s')
2098 if nargs>0 and cmd.find('%l')>=0:
2103 if nargs>0 and cmd.find('%l')>=0:
2099 error('The %s and %l specifiers are mutually exclusive '
2104 error('The %s and %l specifiers are mutually exclusive '
2100 'in alias definitions.')
2105 'in alias definitions.')
2101 else: # all looks OK
2106 else: # all looks OK
2102 self.shell.alias_table[alias] = (nargs,cmd)
2107 self.shell.alias_table[alias] = (nargs,cmd)
2103 self.shell.alias_table_validate(verbose=1)
2108 self.shell.alias_table_validate(verbose=1)
2104 # end magic_alias
2109 # end magic_alias
2105
2110
2106 def magic_unalias(self, parameter_s = ''):
2111 def magic_unalias(self, parameter_s = ''):
2107 """Remove an alias"""
2112 """Remove an alias"""
2108
2113
2109 aname = parameter_s.strip()
2114 aname = parameter_s.strip()
2110 if aname in self.shell.alias_table:
2115 if aname in self.shell.alias_table:
2111 del self.shell.alias_table[aname]
2116 del self.shell.alias_table[aname]
2112
2117
2113 def magic_rehash(self, parameter_s = ''):
2118 def magic_rehash(self, parameter_s = ''):
2114 """Update the alias table with all entries in $PATH.
2119 """Update the alias table with all entries in $PATH.
2115
2120
2116 This version does no checks on execute permissions or whether the
2121 This version does no checks on execute permissions or whether the
2117 contents of $PATH are truly files (instead of directories or something
2122 contents of $PATH are truly files (instead of directories or something
2118 else). For such a safer (but slower) version, use %rehashx."""
2123 else). For such a safer (but slower) version, use %rehashx."""
2119
2124
2120 # This function (and rehashx) manipulate the alias_table directly
2125 # This function (and rehashx) manipulate the alias_table directly
2121 # rather than calling magic_alias, for speed reasons. A rehash on a
2126 # rather than calling magic_alias, for speed reasons. A rehash on a
2122 # typical Linux box involves several thousand entries, so efficiency
2127 # typical Linux box involves several thousand entries, so efficiency
2123 # here is a top concern.
2128 # here is a top concern.
2124
2129
2125 path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
2130 path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
2126 alias_table = self.shell.alias_table
2131 alias_table = self.shell.alias_table
2127 for pdir in path:
2132 for pdir in path:
2128 for ff in os.listdir(pdir):
2133 for ff in os.listdir(pdir):
2129 # each entry in the alias table must be (N,name), where
2134 # each entry in the alias table must be (N,name), where
2130 # N is the number of positional arguments of the alias.
2135 # N is the number of positional arguments of the alias.
2131 alias_table[ff] = (0,ff)
2136 alias_table[ff] = (0,ff)
2132 # Make sure the alias table doesn't contain keywords or builtins
2137 # Make sure the alias table doesn't contain keywords or builtins
2133 self.shell.alias_table_validate()
2138 self.shell.alias_table_validate()
2134 # Call again init_auto_alias() so we get 'rm -i' and other modified
2139 # Call again init_auto_alias() so we get 'rm -i' and other modified
2135 # aliases since %rehash will probably clobber them
2140 # aliases since %rehash will probably clobber them
2136 self.shell.init_auto_alias()
2141 self.shell.init_auto_alias()
2137
2142
2138 def magic_rehashx(self, parameter_s = ''):
2143 def magic_rehashx(self, parameter_s = ''):
2139 """Update the alias table with all executable files in $PATH.
2144 """Update the alias table with all executable files in $PATH.
2140
2145
2141 This version explicitly checks that every entry in $PATH is a file
2146 This version explicitly checks that every entry in $PATH is a file
2142 with execute access (os.X_OK), so it is much slower than %rehash.
2147 with execute access (os.X_OK), so it is much slower than %rehash.
2143
2148
2144 Under Windows, it checks executability as a match agains a
2149 Under Windows, it checks executability as a match agains a
2145 '|'-separated string of extensions, stored in the IPython config
2150 '|'-separated string of extensions, stored in the IPython config
2146 variable win_exec_ext. This defaults to 'exe|com|bat'. """
2151 variable win_exec_ext. This defaults to 'exe|com|bat'. """
2147
2152
2148 path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
2153 path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
2149 alias_table = self.shell.alias_table
2154 alias_table = self.shell.alias_table
2150
2155
2151 if os.name == 'posix':
2156 if os.name == 'posix':
2152 isexec = lambda fname:os.path.isfile(fname) and \
2157 isexec = lambda fname:os.path.isfile(fname) and \
2153 os.access(fname,os.X_OK)
2158 os.access(fname,os.X_OK)
2154 else:
2159 else:
2155
2160
2156 try:
2161 try:
2157 winext = os.environ['pathext'].replace(';','|').replace('.','')
2162 winext = os.environ['pathext'].replace(';','|').replace('.','')
2158 except KeyError:
2163 except KeyError:
2159 winext = 'exe|com|bat'
2164 winext = 'exe|com|bat'
2160
2165
2161 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2166 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2162 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2167 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2163 savedir = os.getcwd()
2168 savedir = os.getcwd()
2164 try:
2169 try:
2165 # write the whole loop for posix/Windows so we don't have an if in
2170 # write the whole loop for posix/Windows so we don't have an if in
2166 # the innermost part
2171 # the innermost part
2167 if os.name == 'posix':
2172 if os.name == 'posix':
2168 for pdir in path:
2173 for pdir in path:
2169 os.chdir(pdir)
2174 os.chdir(pdir)
2170 for ff in os.listdir(pdir):
2175 for ff in os.listdir(pdir):
2171 if isexec(ff):
2176 if isexec(ff):
2172 # each entry in the alias table must be (N,name),
2177 # each entry in the alias table must be (N,name),
2173 # where N is the number of positional arguments of the
2178 # where N is the number of positional arguments of the
2174 # alias.
2179 # alias.
2175 alias_table[ff] = (0,ff)
2180 alias_table[ff] = (0,ff)
2176 else:
2181 else:
2177 for pdir in path:
2182 for pdir in path:
2178 os.chdir(pdir)
2183 os.chdir(pdir)
2179 for ff in os.listdir(pdir):
2184 for ff in os.listdir(pdir):
2180 if isexec(ff):
2185 if isexec(ff):
2181 alias_table[execre.sub(r'\1',ff)] = (0,ff)
2186 alias_table[execre.sub(r'\1',ff)] = (0,ff)
2182 # Make sure the alias table doesn't contain keywords or builtins
2187 # Make sure the alias table doesn't contain keywords or builtins
2183 self.shell.alias_table_validate()
2188 self.shell.alias_table_validate()
2184 # Call again init_auto_alias() so we get 'rm -i' and other
2189 # Call again init_auto_alias() so we get 'rm -i' and other
2185 # modified aliases since %rehashx will probably clobber them
2190 # modified aliases since %rehashx will probably clobber them
2186 self.shell.init_auto_alias()
2191 self.shell.init_auto_alias()
2187 finally:
2192 finally:
2188 os.chdir(savedir)
2193 os.chdir(savedir)
2189
2194
2190 def magic_pwd(self, parameter_s = ''):
2195 def magic_pwd(self, parameter_s = ''):
2191 """Return the current working directory path."""
2196 """Return the current working directory path."""
2192 return os.getcwd()
2197 return os.getcwd()
2193
2198
2194 def magic_cd(self, parameter_s=''):
2199 def magic_cd(self, parameter_s=''):
2195 """Change the current working directory.
2200 """Change the current working directory.
2196
2201
2197 This command automatically maintains an internal list of directories
2202 This command automatically maintains an internal list of directories
2198 you visit during your IPython session, in the variable _dh. The
2203 you visit during your IPython session, in the variable _dh. The
2199 command %dhist shows this history nicely formatted.
2204 command %dhist shows this history nicely formatted.
2200
2205
2201 Usage:
2206 Usage:
2202
2207
2203 cd 'dir': changes to directory 'dir'.
2208 cd 'dir': changes to directory 'dir'.
2204
2209
2205 cd -: changes to the last visited directory.
2210 cd -: changes to the last visited directory.
2206
2211
2207 cd -<n>: changes to the n-th directory in the directory history.
2212 cd -<n>: changes to the n-th directory in the directory history.
2208
2213
2209 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2214 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2210 (note: cd <bookmark_name> is enough if there is no
2215 (note: cd <bookmark_name> is enough if there is no
2211 directory <bookmark_name>, but a bookmark with the name exists.)
2216 directory <bookmark_name>, but a bookmark with the name exists.)
2212
2217
2213 Options:
2218 Options:
2214
2219
2215 -q: quiet. Do not print the working directory after the cd command is
2220 -q: quiet. Do not print the working directory after the cd command is
2216 executed. By default IPython's cd command does print this directory,
2221 executed. By default IPython's cd command does print this directory,
2217 since the default prompts do not display path information.
2222 since the default prompts do not display path information.
2218
2223
2219 Note that !cd doesn't work for this purpose because the shell where
2224 Note that !cd doesn't work for this purpose because the shell where
2220 !command runs is immediately discarded after executing 'command'."""
2225 !command runs is immediately discarded after executing 'command'."""
2221
2226
2222 parameter_s = parameter_s.strip()
2227 parameter_s = parameter_s.strip()
2223 bkms = self.shell.persist.get("bookmarks",{})
2228 bkms = self.shell.persist.get("bookmarks",{})
2224
2229
2225 numcd = re.match(r'(-)(\d+)$',parameter_s)
2230 numcd = re.match(r'(-)(\d+)$',parameter_s)
2226 # jump in directory history by number
2231 # jump in directory history by number
2227 if numcd:
2232 if numcd:
2228 nn = int(numcd.group(2))
2233 nn = int(numcd.group(2))
2229 try:
2234 try:
2230 ps = self.shell.user_ns['_dh'][nn]
2235 ps = self.shell.user_ns['_dh'][nn]
2231 except IndexError:
2236 except IndexError:
2232 print 'The requested directory does not exist in history.'
2237 print 'The requested directory does not exist in history.'
2233 return
2238 return
2234 else:
2239 else:
2235 opts = {}
2240 opts = {}
2236 else:
2241 else:
2237 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2242 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2238 # jump to previous
2243 # jump to previous
2239 if ps == '-':
2244 if ps == '-':
2240 try:
2245 try:
2241 ps = self.shell.user_ns['_dh'][-2]
2246 ps = self.shell.user_ns['_dh'][-2]
2242 except IndexError:
2247 except IndexError:
2243 print 'No previous directory to change to.'
2248 print 'No previous directory to change to.'
2244 return
2249 return
2245 # jump to bookmark
2250 # jump to bookmark
2246 elif opts.has_key('b') or (bkms.has_key(ps) and not os.path.isdir(ps)):
2251 elif opts.has_key('b') or (bkms.has_key(ps) and not os.path.isdir(ps)):
2247 if bkms.has_key(ps):
2252 if bkms.has_key(ps):
2248 target = bkms[ps]
2253 target = bkms[ps]
2249 print '(bookmark:%s) -> %s' % (ps,target)
2254 print '(bookmark:%s) -> %s' % (ps,target)
2250 ps = target
2255 ps = target
2251 else:
2256 else:
2252 if bkms:
2257 if bkms:
2253 error("Bookmark '%s' not found. "
2258 error("Bookmark '%s' not found. "
2254 "Use '%bookmark -l' to see your bookmarks." % ps)
2259 "Use '%bookmark -l' to see your bookmarks." % ps)
2255 else:
2260 else:
2256 print "Bookmarks not set - use %bookmark <bookmarkname>"
2261 print "Bookmarks not set - use %bookmark <bookmarkname>"
2257 return
2262 return
2258
2263
2259 # at this point ps should point to the target dir
2264 # at this point ps should point to the target dir
2260 if ps:
2265 if ps:
2261 try:
2266 try:
2262 os.chdir(os.path.expanduser(ps))
2267 os.chdir(os.path.expanduser(ps))
2263 except OSError:
2268 except OSError:
2264 print sys.exc_info()[1]
2269 print sys.exc_info()[1]
2265 else:
2270 else:
2266 self.shell.user_ns['_dh'].append(os.getcwd())
2271 self.shell.user_ns['_dh'].append(os.getcwd())
2267 else:
2272 else:
2268 os.chdir(self.shell.home_dir)
2273 os.chdir(self.shell.home_dir)
2269 self.shell.user_ns['_dh'].append(os.getcwd())
2274 self.shell.user_ns['_dh'].append(os.getcwd())
2270 if not 'q' in opts:
2275 if not 'q' in opts:
2271 print self.shell.user_ns['_dh'][-1]
2276 print self.shell.user_ns['_dh'][-1]
2272
2277
2273 def magic_dhist(self, parameter_s=''):
2278 def magic_dhist(self, parameter_s=''):
2274 """Print your history of visited directories.
2279 """Print your history of visited directories.
2275
2280
2276 %dhist -> print full history\\
2281 %dhist -> print full history\\
2277 %dhist n -> print last n entries only\\
2282 %dhist n -> print last n entries only\\
2278 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2283 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2279
2284
2280 This history is automatically maintained by the %cd command, and
2285 This history is automatically maintained by the %cd command, and
2281 always available as the global list variable _dh. You can use %cd -<n>
2286 always available as the global list variable _dh. You can use %cd -<n>
2282 to go to directory number <n>."""
2287 to go to directory number <n>."""
2283
2288
2284 dh = self.shell.user_ns['_dh']
2289 dh = self.shell.user_ns['_dh']
2285 if parameter_s:
2290 if parameter_s:
2286 try:
2291 try:
2287 args = map(int,parameter_s.split())
2292 args = map(int,parameter_s.split())
2288 except:
2293 except:
2289 self.arg_err(Magic.magic_dhist)
2294 self.arg_err(Magic.magic_dhist)
2290 return
2295 return
2291 if len(args) == 1:
2296 if len(args) == 1:
2292 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2297 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2293 elif len(args) == 2:
2298 elif len(args) == 2:
2294 ini,fin = args
2299 ini,fin = args
2295 else:
2300 else:
2296 self.arg_err(Magic.magic_dhist)
2301 self.arg_err(Magic.magic_dhist)
2297 return
2302 return
2298 else:
2303 else:
2299 ini,fin = 0,len(dh)
2304 ini,fin = 0,len(dh)
2300 nlprint(dh,
2305 nlprint(dh,
2301 header = 'Directory history (kept in _dh)',
2306 header = 'Directory history (kept in _dh)',
2302 start=ini,stop=fin)
2307 start=ini,stop=fin)
2303
2308
2304 def magic_env(self, parameter_s=''):
2309 def magic_env(self, parameter_s=''):
2305 """List environment variables."""
2310 """List environment variables."""
2306
2311
2307 return os.environ.data
2312 return os.environ.data
2308
2313
2309 def magic_pushd(self, parameter_s=''):
2314 def magic_pushd(self, parameter_s=''):
2310 """Place the current dir on stack and change directory.
2315 """Place the current dir on stack and change directory.
2311
2316
2312 Usage:\\
2317 Usage:\\
2313 %pushd ['dirname']
2318 %pushd ['dirname']
2314
2319
2315 %pushd with no arguments does a %pushd to your home directory.
2320 %pushd with no arguments does a %pushd to your home directory.
2316 """
2321 """
2317 if parameter_s == '': parameter_s = '~'
2322 if parameter_s == '': parameter_s = '~'
2318 dir_s = self.shell.dir_stack
2323 dir_s = self.shell.dir_stack
2319 if len(dir_s)>0 and os.path.expanduser(parameter_s) != \
2324 if len(dir_s)>0 and os.path.expanduser(parameter_s) != \
2320 os.path.expanduser(self.shell.dir_stack[0]):
2325 os.path.expanduser(self.shell.dir_stack[0]):
2321 try:
2326 try:
2322 self.magic_cd(parameter_s)
2327 self.magic_cd(parameter_s)
2323 dir_s.insert(0,os.getcwd().replace(self.home_dir,'~'))
2328 dir_s.insert(0,os.getcwd().replace(self.home_dir,'~'))
2324 self.magic_dirs()
2329 self.magic_dirs()
2325 except:
2330 except:
2326 print 'Invalid directory'
2331 print 'Invalid directory'
2327 else:
2332 else:
2328 print 'You are already there!'
2333 print 'You are already there!'
2329
2334
2330 def magic_popd(self, parameter_s=''):
2335 def magic_popd(self, parameter_s=''):
2331 """Change to directory popped off the top of the stack.
2336 """Change to directory popped off the top of the stack.
2332 """
2337 """
2333 if len (self.shell.dir_stack) > 1:
2338 if len (self.shell.dir_stack) > 1:
2334 self.shell.dir_stack.pop(0)
2339 self.shell.dir_stack.pop(0)
2335 self.magic_cd(self.shell.dir_stack[0])
2340 self.magic_cd(self.shell.dir_stack[0])
2336 print self.shell.dir_stack[0]
2341 print self.shell.dir_stack[0]
2337 else:
2342 else:
2338 print "You can't remove the starting directory from the stack:",\
2343 print "You can't remove the starting directory from the stack:",\
2339 self.shell.dir_stack
2344 self.shell.dir_stack
2340
2345
2341 def magic_dirs(self, parameter_s=''):
2346 def magic_dirs(self, parameter_s=''):
2342 """Return the current directory stack."""
2347 """Return the current directory stack."""
2343
2348
2344 return self.shell.dir_stack[:]
2349 return self.shell.dir_stack[:]
2345
2350
2346 def magic_sc(self, parameter_s=''):
2351 def magic_sc(self, parameter_s=''):
2347 """Shell capture - execute a shell command and capture its output.
2352 """Shell capture - execute a shell command and capture its output.
2348
2353
2349 %sc [options] varname=command
2354 %sc [options] varname=command
2350
2355
2351 IPython will run the given command using commands.getoutput(), and
2356 IPython will run the given command using commands.getoutput(), and
2352 will then update the user's interactive namespace with a variable
2357 will then update the user's interactive namespace with a variable
2353 called varname, containing the value of the call. Your command can
2358 called varname, containing the value of the call. Your command can
2354 contain shell wildcards, pipes, etc.
2359 contain shell wildcards, pipes, etc.
2355
2360
2356 The '=' sign in the syntax is mandatory, and the variable name you
2361 The '=' sign in the syntax is mandatory, and the variable name you
2357 supply must follow Python's standard conventions for valid names.
2362 supply must follow Python's standard conventions for valid names.
2358
2363
2359 Options:
2364 Options:
2360
2365
2361 -l: list output. Split the output on newlines into a list before
2366 -l: list output. Split the output on newlines into a list before
2362 assigning it to the given variable. By default the output is stored
2367 assigning it to the given variable. By default the output is stored
2363 as a single string.
2368 as a single string.
2364
2369
2365 -v: verbose. Print the contents of the variable.
2370 -v: verbose. Print the contents of the variable.
2366
2371
2367 In most cases you should not need to split as a list, because the
2372 In most cases you should not need to split as a list, because the
2368 returned value is a special type of string which can automatically
2373 returned value is a special type of string which can automatically
2369 provide its contents either as a list (split on newlines) or as a
2374 provide its contents either as a list (split on newlines) or as a
2370 space-separated string. These are convenient, respectively, either
2375 space-separated string. These are convenient, respectively, either
2371 for sequential processing or to be passed to a shell command.
2376 for sequential processing or to be passed to a shell command.
2372
2377
2373 For example:
2378 For example:
2374
2379
2375 # Capture into variable a
2380 # Capture into variable a
2376 In [9]: sc a=ls *py
2381 In [9]: sc a=ls *py
2377
2382
2378 # a is a string with embedded newlines
2383 # a is a string with embedded newlines
2379 In [10]: a
2384 In [10]: a
2380 Out[10]: 'setup.py\nwin32_manual_post_install.py'
2385 Out[10]: 'setup.py\nwin32_manual_post_install.py'
2381
2386
2382 # which can be seen as a list:
2387 # which can be seen as a list:
2383 In [11]: a.l
2388 In [11]: a.l
2384 Out[11]: ['setup.py', 'win32_manual_post_install.py']
2389 Out[11]: ['setup.py', 'win32_manual_post_install.py']
2385
2390
2386 # or as a whitespace-separated string:
2391 # or as a whitespace-separated string:
2387 In [12]: a.s
2392 In [12]: a.s
2388 Out[12]: 'setup.py win32_manual_post_install.py'
2393 Out[12]: 'setup.py win32_manual_post_install.py'
2389
2394
2390 # a.s is useful to pass as a single command line:
2395 # a.s is useful to pass as a single command line:
2391 In [13]: !wc -l $a.s
2396 In [13]: !wc -l $a.s
2392 146 setup.py
2397 146 setup.py
2393 130 win32_manual_post_install.py
2398 130 win32_manual_post_install.py
2394 276 total
2399 276 total
2395
2400
2396 # while the list form is useful to loop over:
2401 # while the list form is useful to loop over:
2397 In [14]: for f in a.l:
2402 In [14]: for f in a.l:
2398 ....: !wc -l $f
2403 ....: !wc -l $f
2399 ....:
2404 ....:
2400 146 setup.py
2405 146 setup.py
2401 130 win32_manual_post_install.py
2406 130 win32_manual_post_install.py
2402
2407
2403 Similiarly, the lists returned by the -l option are also special, in
2408 Similiarly, the lists returned by the -l option are also special, in
2404 the sense that you can equally invoke the .s attribute on them to
2409 the sense that you can equally invoke the .s attribute on them to
2405 automatically get a whitespace-separated string from their contents:
2410 automatically get a whitespace-separated string from their contents:
2406
2411
2407 In [1]: sc -l b=ls *py
2412 In [1]: sc -l b=ls *py
2408
2413
2409 In [2]: b
2414 In [2]: b
2410 Out[2]: ['setup.py', 'win32_manual_post_install.py']
2415 Out[2]: ['setup.py', 'win32_manual_post_install.py']
2411
2416
2412 In [3]: b.s
2417 In [3]: b.s
2413 Out[3]: 'setup.py win32_manual_post_install.py'
2418 Out[3]: 'setup.py win32_manual_post_install.py'
2414
2419
2415 In summary, both the lists and strings used for ouptut capture have
2420 In summary, both the lists and strings used for ouptut capture have
2416 the following special attributes:
2421 the following special attributes:
2417
2422
2418 .l (or .list) : value as list.
2423 .l (or .list) : value as list.
2419 .n (or .nlstr): value as newline-separated string.
2424 .n (or .nlstr): value as newline-separated string.
2420 .s (or .spstr): value as space-separated string.
2425 .s (or .spstr): value as space-separated string.
2421 """
2426 """
2422
2427
2423 opts,args = self.parse_options(parameter_s,'lv')
2428 opts,args = self.parse_options(parameter_s,'lv')
2424 # Try to get a variable name and command to run
2429 # Try to get a variable name and command to run
2425 try:
2430 try:
2426 # the variable name must be obtained from the parse_options
2431 # the variable name must be obtained from the parse_options
2427 # output, which uses shlex.split to strip options out.
2432 # output, which uses shlex.split to strip options out.
2428 var,_ = args.split('=',1)
2433 var,_ = args.split('=',1)
2429 var = var.strip()
2434 var = var.strip()
2430 # But the the command has to be extracted from the original input
2435 # But the the command has to be extracted from the original input
2431 # parameter_s, not on what parse_options returns, to avoid the
2436 # parameter_s, not on what parse_options returns, to avoid the
2432 # quote stripping which shlex.split performs on it.
2437 # quote stripping which shlex.split performs on it.
2433 _,cmd = parameter_s.split('=',1)
2438 _,cmd = parameter_s.split('=',1)
2434 except ValueError:
2439 except ValueError:
2435 var,cmd = '',''
2440 var,cmd = '',''
2436 if not var:
2441 if not var:
2437 error('you must specify a variable to assign the command to.')
2442 error('you must specify a variable to assign the command to.')
2438 return
2443 return
2439 # If all looks ok, proceed
2444 # If all looks ok, proceed
2440 out,err = self.shell.getoutputerror(cmd)
2445 out,err = self.shell.getoutputerror(cmd)
2441 if err:
2446 if err:
2442 print >> Term.cerr,err
2447 print >> Term.cerr,err
2443 if opts.has_key('l'):
2448 if opts.has_key('l'):
2444 out = SList(out.split('\n'))
2449 out = SList(out.split('\n'))
2445 else:
2450 else:
2446 out = LSString(out)
2451 out = LSString(out)
2447 if opts.has_key('v'):
2452 if opts.has_key('v'):
2448 print '%s ==\n%s' % (var,pformat(out))
2453 print '%s ==\n%s' % (var,pformat(out))
2449 self.shell.user_ns.update({var:out})
2454 self.shell.user_ns.update({var:out})
2450
2455
2451 def magic_sx(self, parameter_s=''):
2456 def magic_sx(self, parameter_s=''):
2452 """Shell execute - run a shell command and capture its output.
2457 """Shell execute - run a shell command and capture its output.
2453
2458
2454 %sx command
2459 %sx command
2455
2460
2456 IPython will run the given command using commands.getoutput(), and
2461 IPython will run the given command using commands.getoutput(), and
2457 return the result formatted as a list (split on '\\n'). Since the
2462 return the result formatted as a list (split on '\\n'). Since the
2458 output is _returned_, it will be stored in ipython's regular output
2463 output is _returned_, it will be stored in ipython's regular output
2459 cache Out[N] and in the '_N' automatic variables.
2464 cache Out[N] and in the '_N' automatic variables.
2460
2465
2461 Notes:
2466 Notes:
2462
2467
2463 1) If an input line begins with '!!', then %sx is automatically
2468 1) If an input line begins with '!!', then %sx is automatically
2464 invoked. That is, while:
2469 invoked. That is, while:
2465 !ls
2470 !ls
2466 causes ipython to simply issue system('ls'), typing
2471 causes ipython to simply issue system('ls'), typing
2467 !!ls
2472 !!ls
2468 is a shorthand equivalent to:
2473 is a shorthand equivalent to:
2469 %sx ls
2474 %sx ls
2470
2475
2471 2) %sx differs from %sc in that %sx automatically splits into a list,
2476 2) %sx differs from %sc in that %sx automatically splits into a list,
2472 like '%sc -l'. The reason for this is to make it as easy as possible
2477 like '%sc -l'. The reason for this is to make it as easy as possible
2473 to process line-oriented shell output via further python commands.
2478 to process line-oriented shell output via further python commands.
2474 %sc is meant to provide much finer control, but requires more
2479 %sc is meant to provide much finer control, but requires more
2475 typing.
2480 typing.
2476
2481
2477 3) Just like %sc -l, this is a list with special attributes:
2482 3) Just like %sc -l, this is a list with special attributes:
2478
2483
2479 .l (or .list) : value as list.
2484 .l (or .list) : value as list.
2480 .n (or .nlstr): value as newline-separated string.
2485 .n (or .nlstr): value as newline-separated string.
2481 .s (or .spstr): value as whitespace-separated string.
2486 .s (or .spstr): value as whitespace-separated string.
2482
2487
2483 This is very useful when trying to use such lists as arguments to
2488 This is very useful when trying to use such lists as arguments to
2484 system commands."""
2489 system commands."""
2485
2490
2486 if parameter_s:
2491 if parameter_s:
2487 out,err = self.shell.getoutputerror(parameter_s)
2492 out,err = self.shell.getoutputerror(parameter_s)
2488 if err:
2493 if err:
2489 print >> Term.cerr,err
2494 print >> Term.cerr,err
2490 return SList(out.split('\n'))
2495 return SList(out.split('\n'))
2491
2496
2492 def magic_bg(self, parameter_s=''):
2497 def magic_bg(self, parameter_s=''):
2493 """Run a job in the background, in a separate thread.
2498 """Run a job in the background, in a separate thread.
2494
2499
2495 For example,
2500 For example,
2496
2501
2497 %bg myfunc(x,y,z=1)
2502 %bg myfunc(x,y,z=1)
2498
2503
2499 will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
2504 will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
2500 execution starts, a message will be printed indicating the job
2505 execution starts, a message will be printed indicating the job
2501 number. If your job number is 5, you can use
2506 number. If your job number is 5, you can use
2502
2507
2503 myvar = jobs.result(5) or myvar = jobs[5].result
2508 myvar = jobs.result(5) or myvar = jobs[5].result
2504
2509
2505 to assign this result to variable 'myvar'.
2510 to assign this result to variable 'myvar'.
2506
2511
2507 IPython has a job manager, accessible via the 'jobs' object. You can
2512 IPython has a job manager, accessible via the 'jobs' object. You can
2508 type jobs? to get more information about it, and use jobs.<TAB> to see
2513 type jobs? to get more information about it, and use jobs.<TAB> to see
2509 its attributes. All attributes not starting with an underscore are
2514 its attributes. All attributes not starting with an underscore are
2510 meant for public use.
2515 meant for public use.
2511
2516
2512 In particular, look at the jobs.new() method, which is used to create
2517 In particular, look at the jobs.new() method, which is used to create
2513 new jobs. This magic %bg function is just a convenience wrapper
2518 new jobs. This magic %bg function is just a convenience wrapper
2514 around jobs.new(), for expression-based jobs. If you want to create a
2519 around jobs.new(), for expression-based jobs. If you want to create a
2515 new job with an explicit function object and arguments, you must call
2520 new job with an explicit function object and arguments, you must call
2516 jobs.new() directly.
2521 jobs.new() directly.
2517
2522
2518 The jobs.new docstring also describes in detail several important
2523 The jobs.new docstring also describes in detail several important
2519 caveats associated with a thread-based model for background job
2524 caveats associated with a thread-based model for background job
2520 execution. Type jobs.new? for details.
2525 execution. Type jobs.new? for details.
2521
2526
2522 You can check the status of all jobs with jobs.status().
2527 You can check the status of all jobs with jobs.status().
2523
2528
2524 The jobs variable is set by IPython into the Python builtin namespace.
2529 The jobs variable is set by IPython into the Python builtin namespace.
2525 If you ever declare a variable named 'jobs', you will shadow this
2530 If you ever declare a variable named 'jobs', you will shadow this
2526 name. You can either delete your global jobs variable to regain
2531 name. You can either delete your global jobs variable to regain
2527 access to the job manager, or make a new name and assign it manually
2532 access to the job manager, or make a new name and assign it manually
2528 to the manager (stored in IPython's namespace). For example, to
2533 to the manager (stored in IPython's namespace). For example, to
2529 assign the job manager to the Jobs name, use:
2534 assign the job manager to the Jobs name, use:
2530
2535
2531 Jobs = __builtins__.jobs"""
2536 Jobs = __builtins__.jobs"""
2532
2537
2533 self.shell.jobs.new(parameter_s,self.shell.user_ns)
2538 self.shell.jobs.new(parameter_s,self.shell.user_ns)
2534
2539
2535 def magic_store(self, parameter_s=''):
2540 def magic_store(self, parameter_s=''):
2536 """Lightweight persistence for python variables.
2541 """Lightweight persistence for python variables.
2537
2542
2538 Example:
2543 Example:
2539
2544
2540 ville@badger[~]|1> A = ['hello',10,'world']\\
2545 ville@badger[~]|1> A = ['hello',10,'world']\\
2541 ville@badger[~]|2> %store A\\
2546 ville@badger[~]|2> %store A\\
2542 ville@badger[~]|3> Exit
2547 ville@badger[~]|3> Exit
2543
2548
2544 (IPython session is closed and started again...)
2549 (IPython session is closed and started again...)
2545
2550
2546 ville@badger:~$ ipython -p pysh\\
2551 ville@badger:~$ ipython -p pysh\\
2547 ville@badger[~]|1> print A
2552 ville@badger[~]|1> print A
2548
2553
2549 ['hello', 10, 'world']
2554 ['hello', 10, 'world']
2550
2555
2551 Usage:
2556 Usage:
2552
2557
2553 %store - Show list of all variables and their current values\\
2558 %store - Show list of all variables and their current values\\
2554 %store <var> - Store the *current* value of the variable to disk\\
2559 %store <var> - Store the *current* value of the variable to disk\\
2555 %store -d - Remove the variable and its value from storage\\
2560 %store -d - Remove the variable and its value from storage\\
2556 %store -r - Remove all variables from storage
2561 %store -r - Remove all variables from storage
2557
2562
2558 It should be noted that if you change the value of a variable, you
2563 It should be noted that if you change the value of a variable, you
2559 need to %store it again if you want to persist the new value.
2564 need to %store it again if you want to persist the new value.
2560
2565
2561 Note also that the variables will need to be pickleable; most basic
2566 Note also that the variables will need to be pickleable; most basic
2562 python types can be safely %stored.
2567 python types can be safely %stored.
2563 """
2568 """
2564
2569
2565 opts,args = self.parse_options(parameter_s,'dr',mode='list')
2570 opts,args = self.parse_options(parameter_s,'dr',mode='list')
2566 # delete
2571 # delete
2567 if opts.has_key('d'):
2572 if opts.has_key('d'):
2568 try:
2573 try:
2569 todel = args[0]
2574 todel = args[0]
2570 except IndexError:
2575 except IndexError:
2571 error('You must provide the variable to forget')
2576 error('You must provide the variable to forget')
2572 else:
2577 else:
2573 try:
2578 try:
2574 del self.shell.persist['S:' + todel]
2579 del self.shell.persist['S:' + todel]
2575 except:
2580 except:
2576 error("Can't delete variable '%s'" % todel)
2581 error("Can't delete variable '%s'" % todel)
2577 # reset
2582 # reset
2578 elif opts.has_key('r'):
2583 elif opts.has_key('r'):
2579 for k in self.shell.persist.keys():
2584 for k in self.shell.persist.keys():
2580 if k.startswith('S:'):
2585 if k.startswith('S:'):
2581 del self.shell.persist[k]
2586 del self.shell.persist[k]
2582
2587
2583 # run without arguments -> list variables & values
2588 # run without arguments -> list variables & values
2584 elif not args:
2589 elif not args:
2585 vars = [v[2:] for v in self.shell.persist.keys()
2590 vars = [v[2:] for v in self.shell.persist.keys()
2586 if v.startswith('S:')]
2591 if v.startswith('S:')]
2587 vars.sort()
2592 vars.sort()
2588 if vars:
2593 if vars:
2589 size = max(map(len,vars))
2594 size = max(map(len,vars))
2590 else:
2595 else:
2591 size = 0
2596 size = 0
2592
2597
2593 print 'Stored variables and their in-memory values:'
2598 print 'Stored variables and their in-memory values:'
2594 fmt = '%-'+str(size)+'s -> %s'
2599 fmt = '%-'+str(size)+'s -> %s'
2595 get = self.shell.user_ns.get
2600 get = self.shell.user_ns.get
2596 for var in vars:
2601 for var in vars:
2597 # print 30 first characters from every var
2602 # print 30 first characters from every var
2598 print fmt % (var,repr(get(var,'<unavailable>'))[:50])
2603 print fmt % (var,repr(get(var,'<unavailable>'))[:50])
2599
2604
2600 # default action - store the variable
2605 # default action - store the variable
2601 else:
2606 else:
2602 pickled = pickle.dumps(self.shell.user_ns[args[0] ])
2607 pickled = pickle.dumps(self.shell.user_ns[args[0] ])
2603 self.shell.persist[ 'S:' + args[0] ] = pickled
2608 self.shell.persist[ 'S:' + args[0] ] = pickled
2604 print "Stored '%s' (%d bytes)" % (args[0], len(pickled))
2609 print "Stored '%s' (%d bytes)" % (args[0], len(pickled))
2605
2610
2606 def magic_bookmark(self, parameter_s=''):
2611 def magic_bookmark(self, parameter_s=''):
2607 """Manage IPython's bookmark system.
2612 """Manage IPython's bookmark system.
2608
2613
2609 %bookmark <name> - set bookmark to current dir
2614 %bookmark <name> - set bookmark to current dir
2610 %bookmark <name> <dir> - set bookmark to <dir>
2615 %bookmark <name> <dir> - set bookmark to <dir>
2611 %bookmark -l - list all bookmarks
2616 %bookmark -l - list all bookmarks
2612 %bookmark -d <name> - remove bookmark
2617 %bookmark -d <name> - remove bookmark
2613 %bookmark -r - remove all bookmarks
2618 %bookmark -r - remove all bookmarks
2614
2619
2615 You can later on access a bookmarked folder with:
2620 You can later on access a bookmarked folder with:
2616 %cd -b <name>
2621 %cd -b <name>
2617 or simply '%cd <name>' if there is no directory called <name> AND
2622 or simply '%cd <name>' if there is no directory called <name> AND
2618 there is such a bookmark defined.
2623 there is such a bookmark defined.
2619
2624
2620 Your bookmarks persist through IPython sessions, but they are
2625 Your bookmarks persist through IPython sessions, but they are
2621 associated with each profile."""
2626 associated with each profile."""
2622
2627
2623 opts,args = self.parse_options(parameter_s,'drl',mode='list')
2628 opts,args = self.parse_options(parameter_s,'drl',mode='list')
2624 if len(args) > 2:
2629 if len(args) > 2:
2625 error('You can only give at most two arguments')
2630 error('You can only give at most two arguments')
2626 return
2631 return
2627
2632
2628 bkms = self.shell.persist.get('bookmarks',{})
2633 bkms = self.shell.persist.get('bookmarks',{})
2629
2634
2630 if opts.has_key('d'):
2635 if opts.has_key('d'):
2631 try:
2636 try:
2632 todel = args[0]
2637 todel = args[0]
2633 except IndexError:
2638 except IndexError:
2634 error('You must provide a bookmark to delete')
2639 error('You must provide a bookmark to delete')
2635 else:
2640 else:
2636 try:
2641 try:
2637 del bkms[todel]
2642 del bkms[todel]
2638 except:
2643 except:
2639 error("Can't delete bookmark '%s'" % todel)
2644 error("Can't delete bookmark '%s'" % todel)
2640 elif opts.has_key('r'):
2645 elif opts.has_key('r'):
2641 bkms = {}
2646 bkms = {}
2642 elif opts.has_key('l'):
2647 elif opts.has_key('l'):
2643 bks = bkms.keys()
2648 bks = bkms.keys()
2644 bks.sort()
2649 bks.sort()
2645 if bks:
2650 if bks:
2646 size = max(map(len,bks))
2651 size = max(map(len,bks))
2647 else:
2652 else:
2648 size = 0
2653 size = 0
2649 fmt = '%-'+str(size)+'s -> %s'
2654 fmt = '%-'+str(size)+'s -> %s'
2650 print 'Current bookmarks:'
2655 print 'Current bookmarks:'
2651 for bk in bks:
2656 for bk in bks:
2652 print fmt % (bk,bkms[bk])
2657 print fmt % (bk,bkms[bk])
2653 else:
2658 else:
2654 if not args:
2659 if not args:
2655 error("You must specify the bookmark name")
2660 error("You must specify the bookmark name")
2656 elif len(args)==1:
2661 elif len(args)==1:
2657 bkms[args[0]] = os.getcwd()
2662 bkms[args[0]] = os.getcwd()
2658 elif len(args)==2:
2663 elif len(args)==2:
2659 bkms[args[0]] = args[1]
2664 bkms[args[0]] = args[1]
2660 self.shell.persist['bookmarks'] = bkms
2665 self.shell.persist['bookmarks'] = bkms
2661
2666
2662 def magic_pycat(self, parameter_s=''):
2667 def magic_pycat(self, parameter_s=''):
2663 """Show a syntax-highlighted file through a pager.
2668 """Show a syntax-highlighted file through a pager.
2664
2669
2665 This magic is similar to the cat utility, but it will assume the file
2670 This magic is similar to the cat utility, but it will assume the file
2666 to be Python source and will show it with syntax highlighting. """
2671 to be Python source and will show it with syntax highlighting. """
2667
2672
2668 filename = get_py_filename(parameter_s)
2673 filename = get_py_filename(parameter_s)
2669 page(self.shell.colorize(file_read(filename)),
2674 page(self.shell.colorize(file_read(filename)),
2670 screen_lines=self.shell.rc.screen_length)
2675 screen_lines=self.shell.rc.screen_length)
2671
2676
2672 # end Magic
2677 # end Magic
@@ -1,76 +1,76 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Release data for the IPython project.
2 """Release data for the IPython project.
3
3
4 $Id: Release.py 982 2005-12-30 23:57:07Z fperez $"""
4 $Id: Release.py 984 2005-12-31 08:40:31Z fperez $"""
5
5
6 #*****************************************************************************
6 #*****************************************************************************
7 # Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
7 # Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
8 #
8 #
9 # Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
9 # Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
10 # <n8gray@caltech.edu>
10 # <n8gray@caltech.edu>
11 #
11 #
12 # Distributed under the terms of the BSD License. The full license is in
12 # Distributed under the terms of the BSD License. The full license is in
13 # the file COPYING, distributed as part of this software.
13 # the file COPYING, distributed as part of this software.
14 #*****************************************************************************
14 #*****************************************************************************
15
15
16 # Name of the package for release purposes. This is the name which labels
16 # Name of the package for release purposes. This is the name which labels
17 # the tarballs and RPMs made by distutils, so it's best to lowercase it.
17 # the tarballs and RPMs made by distutils, so it's best to lowercase it.
18 name = 'ipython'
18 name = 'ipython'
19
19
20 # For versions with substrings (like 0.6.16.svn), use an extra . to separate
20 # For versions with substrings (like 0.6.16.svn), use an extra . to separate
21 # the new substring. We have to avoid using either dashes or underscores,
21 # the new substring. We have to avoid using either dashes or underscores,
22 # because bdist_rpm does not accept dashes (an RPM) convention, and
22 # because bdist_rpm does not accept dashes (an RPM) convention, and
23 # bdist_deb does not accept underscores (a Debian convention).
23 # bdist_deb does not accept underscores (a Debian convention).
24
24
25 version = '0.7.0.rc3'
25 version = '0.7.0.rc4'
26
26
27 revision = '$Revision: 982 $'
27 revision = '$Revision: 984 $'
28
28
29 description = "An enhanced interactive Python shell."
29 description = "An enhanced interactive Python shell."
30
30
31 long_description = \
31 long_description = \
32 """
32 """
33 IPython provides a replacement for the interactive Python interpreter with
33 IPython provides a replacement for the interactive Python interpreter with
34 extra functionality.
34 extra functionality.
35
35
36 Main features:
36 Main features:
37
37
38 * Comprehensive object introspection.
38 * Comprehensive object introspection.
39
39
40 * Input history, persistent across sessions.
40 * Input history, persistent across sessions.
41
41
42 * Caching of output results during a session with automatically generated
42 * Caching of output results during a session with automatically generated
43 references.
43 references.
44
44
45 * Readline based name completion.
45 * Readline based name completion.
46
46
47 * Extensible system of 'magic' commands for controlling the environment and
47 * Extensible system of 'magic' commands for controlling the environment and
48 performing many tasks related either to IPython or the operating system.
48 performing many tasks related either to IPython or the operating system.
49
49
50 * Configuration system with easy switching between different setups (simpler
50 * Configuration system with easy switching between different setups (simpler
51 than changing $PYTHONSTARTUP environment variables every time).
51 than changing $PYTHONSTARTUP environment variables every time).
52
52
53 * Session logging and reloading.
53 * Session logging and reloading.
54
54
55 * Extensible syntax processing for special purpose situations.
55 * Extensible syntax processing for special purpose situations.
56
56
57 * Access to the system shell with user-extensible alias system.
57 * Access to the system shell with user-extensible alias system.
58
58
59 * Easily embeddable in other Python programs.
59 * Easily embeddable in other Python programs.
60
60
61 * Integrated access to the pdb debugger and the Python profiler. """
61 * Integrated access to the pdb debugger and the Python profiler. """
62
62
63 license = 'BSD'
63 license = 'BSD'
64
64
65 authors = {'Fernando' : ('Fernando Perez','fperez@colorado.edu'),
65 authors = {'Fernando' : ('Fernando Perez','fperez@colorado.edu'),
66 'Janko' : ('Janko Hauser','jhauser@zscout.de'),
66 'Janko' : ('Janko Hauser','jhauser@zscout.de'),
67 'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu')
67 'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu')
68 }
68 }
69
69
70 url = 'http://ipython.scipy.org'
70 url = 'http://ipython.scipy.org'
71
71
72 download_url = 'http://ipython.scipy.org/dist'
72 download_url = 'http://ipython.scipy.org/dist'
73
73
74 platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
74 platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
75
75
76 keywords = ['Interactive','Interpreter','Shell']
76 keywords = ['Interactive','Interpreter','Shell']
@@ -1,2060 +1,2058 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 IPython -- An enhanced Interactive Python
3 IPython -- An enhanced Interactive Python
4
4
5 Requires Python 2.1 or newer.
5 Requires Python 2.1 or newer.
6
6
7 This file contains all the classes and helper functions specific to IPython.
7 This file contains all the classes and helper functions specific to IPython.
8
8
9 $Id: iplib.py 983 2005-12-31 00:04:25Z fperez $
9 $Id: iplib.py 984 2005-12-31 08:40:31Z fperez $
10 """
10 """
11
11
12 #*****************************************************************************
12 #*****************************************************************************
13 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
13 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
14 # Copyright (C) 2001-2005 Fernando Perez. <fperez@colorado.edu>
14 # Copyright (C) 2001-2005 Fernando Perez. <fperez@colorado.edu>
15 #
15 #
16 # Distributed under the terms of the BSD License. The full license is in
16 # Distributed under the terms of the BSD License. The full license is in
17 # the file COPYING, distributed as part of this software.
17 # the file COPYING, distributed as part of this software.
18 #
18 #
19 # Note: this code originally subclassed code.InteractiveConsole from the
19 # Note: this code originally subclassed code.InteractiveConsole from the
20 # Python standard library. Over time, all of that class has been copied
20 # Python standard library. Over time, all of that class has been copied
21 # verbatim here for modifications which could not be accomplished by
21 # verbatim here for modifications which could not be accomplished by
22 # subclassing. At this point, there are no dependencies at all on the code
22 # subclassing. At this point, there are no dependencies at all on the code
23 # module anymore (it is not even imported). The Python License (sec. 2)
23 # module anymore (it is not even imported). The Python License (sec. 2)
24 # allows for this, but it's always nice to acknowledge credit where credit is
24 # allows for this, but it's always nice to acknowledge credit where credit is
25 # due.
25 # due.
26 #*****************************************************************************
26 #*****************************************************************************
27
27
28 #****************************************************************************
28 #****************************************************************************
29 # Modules and globals
29 # Modules and globals
30
30
31 from __future__ import generators # for 2.2 backwards-compatibility
31 from __future__ import generators # for 2.2 backwards-compatibility
32
32
33 from IPython import Release
33 from IPython import Release
34 __author__ = '%s <%s>\n%s <%s>' % \
34 __author__ = '%s <%s>\n%s <%s>' % \
35 ( Release.authors['Janko'] + Release.authors['Fernando'] )
35 ( Release.authors['Janko'] + Release.authors['Fernando'] )
36 __license__ = Release.license
36 __license__ = Release.license
37 __version__ = Release.version
37 __version__ = Release.version
38
38
39 # Python standard modules
39 # Python standard modules
40 import __main__
40 import __main__
41 import __builtin__
41 import __builtin__
42 import StringIO
42 import StringIO
43 import bdb
43 import bdb
44 import cPickle as pickle
44 import cPickle as pickle
45 import codeop
45 import codeop
46 import exceptions
46 import exceptions
47 import glob
47 import glob
48 import inspect
48 import inspect
49 import keyword
49 import keyword
50 import new
50 import new
51 import os
51 import os
52 import pdb
52 import pdb
53 import pydoc
53 import pydoc
54 import re
54 import re
55 import shutil
55 import shutil
56 import string
56 import string
57 import sys
57 import sys
58 import traceback
58 import traceback
59 import types
59 import types
60
60
61 from pprint import pprint, pformat
61 from pprint import pprint, pformat
62
62
63 # IPython's own modules
63 # IPython's own modules
64 import IPython
64 import IPython
65 from IPython import OInspect,PyColorize,ultraTB
65 from IPython import OInspect,PyColorize,ultraTB
66 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
66 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
67 from IPython.FakeModule import FakeModule
67 from IPython.FakeModule import FakeModule
68 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
68 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
69 from IPython.Logger import Logger
69 from IPython.Logger import Logger
70 from IPython.Magic import Magic
70 from IPython.Magic import Magic
71 from IPython.Prompts import CachedOutput
71 from IPython.Prompts import CachedOutput
72 from IPython.Struct import Struct
72 from IPython.Struct import Struct
73 from IPython.background_jobs import BackgroundJobManager
73 from IPython.background_jobs import BackgroundJobManager
74 from IPython.usage import cmd_line_usage,interactive_usage
74 from IPython.usage import cmd_line_usage,interactive_usage
75 from IPython.genutils import *
75 from IPython.genutils import *
76
76
77 # store the builtin raw_input globally, and use this always, in case user code
77 # store the builtin raw_input globally, and use this always, in case user code
78 # overwrites it (like wx.py.PyShell does)
78 # overwrites it (like wx.py.PyShell does)
79 raw_input_original = raw_input
79 raw_input_original = raw_input
80
80
81 # compiled regexps for autoindent management
81 # compiled regexps for autoindent management
82 ini_spaces_re = re.compile(r'^(\s+)')
82 ini_spaces_re = re.compile(r'^(\s+)')
83 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
83 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
84
84
85 #****************************************************************************
85 #****************************************************************************
86 # Some utility function definitions
86 # Some utility function definitions
87
87
88 def softspace(file, newvalue):
88 def softspace(file, newvalue):
89 """Copied from code.py, to remove the dependency"""
89 """Copied from code.py, to remove the dependency"""
90 oldvalue = 0
90 oldvalue = 0
91 try:
91 try:
92 oldvalue = file.softspace
92 oldvalue = file.softspace
93 except AttributeError:
93 except AttributeError:
94 pass
94 pass
95 try:
95 try:
96 file.softspace = newvalue
96 file.softspace = newvalue
97 except (AttributeError, TypeError):
97 except (AttributeError, TypeError):
98 # "attribute-less object" or "read-only attributes"
98 # "attribute-less object" or "read-only attributes"
99 pass
99 pass
100 return oldvalue
100 return oldvalue
101
101
102 #****************************************************************************
102 #****************************************************************************
103 # These special functions get installed in the builtin namespace, to provide
103 # These special functions get installed in the builtin namespace, to provide
104 # programmatic (pure python) access to magics, aliases and system calls. This
104 # programmatic (pure python) access to magics, aliases and system calls. This
105 # is important for logging, user scripting, and more.
105 # is important for logging, user scripting, and more.
106
106
107 # We are basically exposing, via normal python functions, the three mechanisms
107 # We are basically exposing, via normal python functions, the three mechanisms
108 # in which ipython offers special call modes (magics for internal control,
108 # in which ipython offers special call modes (magics for internal control,
109 # aliases for direct system access via pre-selected names, and !cmd for
109 # aliases for direct system access via pre-selected names, and !cmd for
110 # calling arbitrary system commands).
110 # calling arbitrary system commands).
111
111
112 def ipmagic(arg_s):
112 def ipmagic(arg_s):
113 """Call a magic function by name.
113 """Call a magic function by name.
114
114
115 Input: a string containing the name of the magic function to call and any
115 Input: a string containing the name of the magic function to call and any
116 additional arguments to be passed to the magic.
116 additional arguments to be passed to the magic.
117
117
118 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
118 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
119 prompt:
119 prompt:
120
120
121 In[1]: %name -opt foo bar
121 In[1]: %name -opt foo bar
122
122
123 To call a magic without arguments, simply use ipmagic('name').
123 To call a magic without arguments, simply use ipmagic('name').
124
124
125 This provides a proper Python function to call IPython's magics in any
125 This provides a proper Python function to call IPython's magics in any
126 valid Python code you can type at the interpreter, including loops and
126 valid Python code you can type at the interpreter, including loops and
127 compound statements. It is added by IPython to the Python builtin
127 compound statements. It is added by IPython to the Python builtin
128 namespace upon initialization."""
128 namespace upon initialization."""
129
129
130 args = arg_s.split(' ',1)
130 args = arg_s.split(' ',1)
131 magic_name = args[0]
131 magic_name = args[0]
132 if magic_name.startswith(__IPYTHON__.ESC_MAGIC):
132 if magic_name.startswith(__IPYTHON__.ESC_MAGIC):
133 magic_name = magic_name[1:]
133 magic_name = magic_name[1:]
134 try:
134 try:
135 magic_args = args[1]
135 magic_args = args[1]
136 except IndexError:
136 except IndexError:
137 magic_args = ''
137 magic_args = ''
138 fn = getattr(__IPYTHON__,'magic_'+magic_name,None)
138 fn = getattr(__IPYTHON__,'magic_'+magic_name,None)
139 if fn is None:
139 if fn is None:
140 error("Magic function `%s` not found." % magic_name)
140 error("Magic function `%s` not found." % magic_name)
141 else:
141 else:
142 magic_args = __IPYTHON__.var_expand(magic_args)
142 magic_args = __IPYTHON__.var_expand(magic_args)
143 return fn(magic_args)
143 return fn(magic_args)
144
144
145 def ipalias(arg_s):
145 def ipalias(arg_s):
146 """Call an alias by name.
146 """Call an alias by name.
147
147
148 Input: a string containing the name of the alias to call and any
148 Input: a string containing the name of the alias to call and any
149 additional arguments to be passed to the magic.
149 additional arguments to be passed to the magic.
150
150
151 ipalias('name -opt foo bar') is equivalent to typing at the ipython
151 ipalias('name -opt foo bar') is equivalent to typing at the ipython
152 prompt:
152 prompt:
153
153
154 In[1]: name -opt foo bar
154 In[1]: name -opt foo bar
155
155
156 To call an alias without arguments, simply use ipalias('name').
156 To call an alias without arguments, simply use ipalias('name').
157
157
158 This provides a proper Python function to call IPython's aliases in any
158 This provides a proper Python function to call IPython's aliases in any
159 valid Python code you can type at the interpreter, including loops and
159 valid Python code you can type at the interpreter, including loops and
160 compound statements. It is added by IPython to the Python builtin
160 compound statements. It is added by IPython to the Python builtin
161 namespace upon initialization."""
161 namespace upon initialization."""
162
162
163 args = arg_s.split(' ',1)
163 args = arg_s.split(' ',1)
164 alias_name = args[0]
164 alias_name = args[0]
165 try:
165 try:
166 alias_args = args[1]
166 alias_args = args[1]
167 except IndexError:
167 except IndexError:
168 alias_args = ''
168 alias_args = ''
169 if alias_name in __IPYTHON__.alias_table:
169 if alias_name in __IPYTHON__.alias_table:
170 __IPYTHON__.call_alias(alias_name,alias_args)
170 __IPYTHON__.call_alias(alias_name,alias_args)
171 else:
171 else:
172 error("Alias `%s` not found." % alias_name)
172 error("Alias `%s` not found." % alias_name)
173
173
174 def ipsystem(arg_s):
174 def ipsystem(arg_s):
175 """Make a system call, using IPython."""
175 """Make a system call, using IPython."""
176 __IPYTHON__.system(arg_s)
176 __IPYTHON__.system(arg_s)
177
177
178
178
179 #****************************************************************************
179 #****************************************************************************
180 # Local use exceptions
180 # Local use exceptions
181 class SpaceInInput(exceptions.Exception): pass
181 class SpaceInInput(exceptions.Exception): pass
182
182
183 #****************************************************************************
183 #****************************************************************************
184 # Local use classes
184 # Local use classes
185 class Bunch: pass
185 class Bunch: pass
186
186
187 class InputList(list):
187 class InputList(list):
188 """Class to store user input.
188 """Class to store user input.
189
189
190 It's basically a list, but slices return a string instead of a list, thus
190 It's basically a list, but slices return a string instead of a list, thus
191 allowing things like (assuming 'In' is an instance):
191 allowing things like (assuming 'In' is an instance):
192
192
193 exec In[4:7]
193 exec In[4:7]
194
194
195 or
195 or
196
196
197 exec In[5:9] + In[14] + In[21:25]"""
197 exec In[5:9] + In[14] + In[21:25]"""
198
198
199 def __getslice__(self,i,j):
199 def __getslice__(self,i,j):
200 return ''.join(list.__getslice__(self,i,j))
200 return ''.join(list.__getslice__(self,i,j))
201
201
202 class SyntaxTB(ultraTB.ListTB):
202 class SyntaxTB(ultraTB.ListTB):
203 """Extension which holds some state: the last exception value"""
203 """Extension which holds some state: the last exception value"""
204
204
205 def __init__(self,color_scheme = 'NoColor'):
205 def __init__(self,color_scheme = 'NoColor'):
206 ultraTB.ListTB.__init__(self,color_scheme)
206 ultraTB.ListTB.__init__(self,color_scheme)
207 self.last_syntax_error = None
207 self.last_syntax_error = None
208
208
209 def __call__(self, etype, value, elist):
209 def __call__(self, etype, value, elist):
210 self.last_syntax_error = value
210 self.last_syntax_error = value
211 ultraTB.ListTB.__call__(self,etype,value,elist)
211 ultraTB.ListTB.__call__(self,etype,value,elist)
212
212
213 def clear_err_state(self):
213 def clear_err_state(self):
214 """Return the current error state and clear it"""
214 """Return the current error state and clear it"""
215 e = self.last_syntax_error
215 e = self.last_syntax_error
216 self.last_syntax_error = None
216 self.last_syntax_error = None
217 return e
217 return e
218
218
219 #****************************************************************************
219 #****************************************************************************
220 # Main IPython class
220 # Main IPython class
221
221
222 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
222 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
223 # until a full rewrite is made. I've cleaned all cross-class uses of
223 # until a full rewrite is made. I've cleaned all cross-class uses of
224 # attributes and methods, but too much user code out there relies on the
224 # attributes and methods, but too much user code out there relies on the
225 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
225 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
226 #
226 #
227 # But at least now, all the pieces have been separated and we could, in
227 # But at least now, all the pieces have been separated and we could, in
228 # principle, stop using the mixin. This will ease the transition to the
228 # principle, stop using the mixin. This will ease the transition to the
229 # chainsaw branch.
229 # chainsaw branch.
230
230
231 # For reference, the following is the list of 'self.foo' uses in the Magic
231 # For reference, the following is the list of 'self.foo' uses in the Magic
232 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
232 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
233 # class, to prevent clashes.
233 # class, to prevent clashes.
234
234
235 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
235 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
236 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
236 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
237 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
237 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
238 # 'self.value']
238 # 'self.value']
239
239
240 class InteractiveShell(Magic):
240 class InteractiveShell(object,Magic):
241 """An enhanced console for Python."""
241 """An enhanced console for Python."""
242
242
243 # class attribute to indicate whether the class supports threads or not.
243 # class attribute to indicate whether the class supports threads or not.
244 # Subclasses with thread support should override this as needed.
244 # Subclasses with thread support should override this as needed.
245 isthreaded = False
245 isthreaded = False
246
246
247 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
247 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
248 user_ns = None,user_global_ns=None,banner2='',
248 user_ns = None,user_global_ns=None,banner2='',
249 custom_exceptions=((),None),embedded=False):
249 custom_exceptions=((),None),embedded=False):
250
250
251 # some minimal strict typechecks. For some core data structures, I
251 # some minimal strict typechecks. For some core data structures, I
252 # want actual basic python types, not just anything that looks like
252 # want actual basic python types, not just anything that looks like
253 # one. This is especially true for namespaces.
253 # one. This is especially true for namespaces.
254 for ns in (user_ns,user_global_ns):
254 for ns in (user_ns,user_global_ns):
255 if ns is not None and type(ns) != types.DictType:
255 if ns is not None and type(ns) != types.DictType:
256 raise TypeError,'namespace must be a dictionary'
256 raise TypeError,'namespace must be a dictionary'
257
257
258 # Put a reference to self in builtins so that any form of embedded or
258 # Put a reference to self in builtins so that any form of embedded or
259 # imported code can test for being inside IPython.
259 # imported code can test for being inside IPython.
260 __builtin__.__IPYTHON__ = self
260 __builtin__.__IPYTHON__ = self
261
261
262 # And load into builtins ipmagic/ipalias/ipsystem as well
262 # And load into builtins ipmagic/ipalias/ipsystem as well
263 __builtin__.ipmagic = ipmagic
263 __builtin__.ipmagic = ipmagic
264 __builtin__.ipalias = ipalias
264 __builtin__.ipalias = ipalias
265 __builtin__.ipsystem = ipsystem
265 __builtin__.ipsystem = ipsystem
266
266
267 # Add to __builtin__ other parts of IPython's public API
267 # Add to __builtin__ other parts of IPython's public API
268 __builtin__.ip_set_hook = self.set_hook
268 __builtin__.ip_set_hook = self.set_hook
269
269
270 # Keep in the builtins a flag for when IPython is active. We set it
270 # Keep in the builtins a flag for when IPython is active. We set it
271 # with setdefault so that multiple nested IPythons don't clobber one
271 # with setdefault so that multiple nested IPythons don't clobber one
272 # another. Each will increase its value by one upon being activated,
272 # another. Each will increase its value by one upon being activated,
273 # which also gives us a way to determine the nesting level.
273 # which also gives us a way to determine the nesting level.
274 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
274 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
275
275
276 # Do the intuitively correct thing for quit/exit: we remove the
276 # Do the intuitively correct thing for quit/exit: we remove the
277 # builtins if they exist, and our own prefilter routine will handle
277 # builtins if they exist, and our own prefilter routine will handle
278 # these special cases
278 # these special cases
279 try:
279 try:
280 del __builtin__.exit, __builtin__.quit
280 del __builtin__.exit, __builtin__.quit
281 except AttributeError:
281 except AttributeError:
282 pass
282 pass
283
283
284 # Store the actual shell's name
284 # Store the actual shell's name
285 self.name = name
285 self.name = name
286
286
287 # We need to know whether the instance is meant for embedding, since
287 # We need to know whether the instance is meant for embedding, since
288 # global/local namespaces need to be handled differently in that case
288 # global/local namespaces need to be handled differently in that case
289 self.embedded = embedded
289 self.embedded = embedded
290
290
291 # command compiler
291 # command compiler
292 self.compile = codeop.CommandCompiler()
292 self.compile = codeop.CommandCompiler()
293
293
294 # User input buffer
294 # User input buffer
295 self.buffer = []
295 self.buffer = []
296
296
297 # Default name given in compilation of code
297 # Default name given in compilation of code
298 self.filename = '<ipython console>'
298 self.filename = '<ipython console>'
299
299
300 # Create the namespace where the user will operate. user_ns is
300 # Create the namespace where the user will operate. user_ns is
301 # normally the only one used, and it is passed to the exec calls as
301 # normally the only one used, and it is passed to the exec calls as
302 # the locals argument. But we do carry a user_global_ns namespace
302 # the locals argument. But we do carry a user_global_ns namespace
303 # given as the exec 'globals' argument, This is useful in embedding
303 # given as the exec 'globals' argument, This is useful in embedding
304 # situations where the ipython shell opens in a context where the
304 # situations where the ipython shell opens in a context where the
305 # distinction between locals and globals is meaningful.
305 # distinction between locals and globals is meaningful.
306
306
307 # FIXME. For some strange reason, __builtins__ is showing up at user
307 # FIXME. For some strange reason, __builtins__ is showing up at user
308 # level as a dict instead of a module. This is a manual fix, but I
308 # level as a dict instead of a module. This is a manual fix, but I
309 # should really track down where the problem is coming from. Alex
309 # should really track down where the problem is coming from. Alex
310 # Schmolck reported this problem first.
310 # Schmolck reported this problem first.
311
311
312 # A useful post by Alex Martelli on this topic:
312 # A useful post by Alex Martelli on this topic:
313 # Re: inconsistent value from __builtins__
313 # Re: inconsistent value from __builtins__
314 # Von: Alex Martelli <aleaxit@yahoo.com>
314 # Von: Alex Martelli <aleaxit@yahoo.com>
315 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
315 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
316 # Gruppen: comp.lang.python
316 # Gruppen: comp.lang.python
317
317
318 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
318 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
319 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
319 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
320 # > <type 'dict'>
320 # > <type 'dict'>
321 # > >>> print type(__builtins__)
321 # > >>> print type(__builtins__)
322 # > <type 'module'>
322 # > <type 'module'>
323 # > Is this difference in return value intentional?
323 # > Is this difference in return value intentional?
324
324
325 # Well, it's documented that '__builtins__' can be either a dictionary
325 # Well, it's documented that '__builtins__' can be either a dictionary
326 # or a module, and it's been that way for a long time. Whether it's
326 # or a module, and it's been that way for a long time. Whether it's
327 # intentional (or sensible), I don't know. In any case, the idea is
327 # intentional (or sensible), I don't know. In any case, the idea is
328 # that if you need to access the built-in namespace directly, you
328 # that if you need to access the built-in namespace directly, you
329 # should start with "import __builtin__" (note, no 's') which will
329 # should start with "import __builtin__" (note, no 's') which will
330 # definitely give you a module. Yeah, it's somewhat confusing:-(.
330 # definitely give you a module. Yeah, it's somewhat confusing:-(.
331
331
332 if user_ns is None:
332 if user_ns is None:
333 # Set __name__ to __main__ to better match the behavior of the
333 # Set __name__ to __main__ to better match the behavior of the
334 # normal interpreter.
334 # normal interpreter.
335 user_ns = {'__name__' :'__main__',
335 user_ns = {'__name__' :'__main__',
336 '__builtins__' : __builtin__,
336 '__builtins__' : __builtin__,
337 }
337 }
338
338
339 if user_global_ns is None:
339 if user_global_ns is None:
340 user_global_ns = {}
340 user_global_ns = {}
341
341
342 # Assign namespaces
342 # Assign namespaces
343 # This is the namespace where all normal user variables live
343 # This is the namespace where all normal user variables live
344 self.user_ns = user_ns
344 self.user_ns = user_ns
345 # Embedded instances require a separate namespace for globals.
345 # Embedded instances require a separate namespace for globals.
346 # Normally this one is unused by non-embedded instances.
346 # Normally this one is unused by non-embedded instances.
347 self.user_global_ns = user_global_ns
347 self.user_global_ns = user_global_ns
348 # A namespace to keep track of internal data structures to prevent
348 # A namespace to keep track of internal data structures to prevent
349 # them from cluttering user-visible stuff. Will be updated later
349 # them from cluttering user-visible stuff. Will be updated later
350 self.internal_ns = {}
350 self.internal_ns = {}
351
351
352 # Namespace of system aliases. Each entry in the alias
352 # Namespace of system aliases. Each entry in the alias
353 # table must be a 2-tuple of the form (N,name), where N is the number
353 # table must be a 2-tuple of the form (N,name), where N is the number
354 # of positional arguments of the alias.
354 # of positional arguments of the alias.
355 self.alias_table = {}
355 self.alias_table = {}
356
356
357 # A table holding all the namespaces IPython deals with, so that
357 # A table holding all the namespaces IPython deals with, so that
358 # introspection facilities can search easily.
358 # introspection facilities can search easily.
359 self.ns_table = {'user':user_ns,
359 self.ns_table = {'user':user_ns,
360 'user_global':user_global_ns,
360 'user_global':user_global_ns,
361 'alias':self.alias_table,
361 'alias':self.alias_table,
362 'internal':self.internal_ns,
362 'internal':self.internal_ns,
363 'builtin':__builtin__.__dict__
363 'builtin':__builtin__.__dict__
364 }
364 }
365
365
366 # The user namespace MUST have a pointer to the shell itself.
366 # The user namespace MUST have a pointer to the shell itself.
367 self.user_ns[name] = self
367 self.user_ns[name] = self
368
368
369 # We need to insert into sys.modules something that looks like a
369 # We need to insert into sys.modules something that looks like a
370 # module but which accesses the IPython namespace, for shelve and
370 # module but which accesses the IPython namespace, for shelve and
371 # pickle to work interactively. Normally they rely on getting
371 # pickle to work interactively. Normally they rely on getting
372 # everything out of __main__, but for embedding purposes each IPython
372 # everything out of __main__, but for embedding purposes each IPython
373 # instance has its own private namespace, so we can't go shoving
373 # instance has its own private namespace, so we can't go shoving
374 # everything into __main__.
374 # everything into __main__.
375
375
376 # note, however, that we should only do this for non-embedded
376 # note, however, that we should only do this for non-embedded
377 # ipythons, which really mimic the __main__.__dict__ with their own
377 # ipythons, which really mimic the __main__.__dict__ with their own
378 # namespace. Embedded instances, on the other hand, should not do
378 # namespace. Embedded instances, on the other hand, should not do
379 # this because they need to manage the user local/global namespaces
379 # this because they need to manage the user local/global namespaces
380 # only, but they live within a 'normal' __main__ (meaning, they
380 # only, but they live within a 'normal' __main__ (meaning, they
381 # shouldn't overtake the execution environment of the script they're
381 # shouldn't overtake the execution environment of the script they're
382 # embedded in).
382 # embedded in).
383
383
384 if not embedded:
384 if not embedded:
385 try:
385 try:
386 main_name = self.user_ns['__name__']
386 main_name = self.user_ns['__name__']
387 except KeyError:
387 except KeyError:
388 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
388 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
389 else:
389 else:
390 #print "pickle hack in place" # dbg
390 #print "pickle hack in place" # dbg
391 #print 'main_name:',main_name # dbg
391 sys.modules[main_name] = FakeModule(self.user_ns)
392 sys.modules[main_name] = FakeModule(self.user_ns)
392
393
393 # List of input with multi-line handling.
394 # List of input with multi-line handling.
394 # Fill its zero entry, user counter starts at 1
395 # Fill its zero entry, user counter starts at 1
395 self.input_hist = InputList(['\n'])
396 self.input_hist = InputList(['\n'])
396
397
397 # list of visited directories
398 # list of visited directories
398 try:
399 try:
399 self.dir_hist = [os.getcwd()]
400 self.dir_hist = [os.getcwd()]
400 except IOError, e:
401 except IOError, e:
401 self.dir_hist = []
402 self.dir_hist = []
402
403
403 # dict of output history
404 # dict of output history
404 self.output_hist = {}
405 self.output_hist = {}
405
406
406 # dict of things NOT to alias (keywords, builtins and some magics)
407 # dict of things NOT to alias (keywords, builtins and some magics)
407 no_alias = {}
408 no_alias = {}
408 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
409 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
409 for key in keyword.kwlist + no_alias_magics:
410 for key in keyword.kwlist + no_alias_magics:
410 no_alias[key] = 1
411 no_alias[key] = 1
411 no_alias.update(__builtin__.__dict__)
412 no_alias.update(__builtin__.__dict__)
412 self.no_alias = no_alias
413 self.no_alias = no_alias
413
414
414 # make global variables for user access to these
415 # make global variables for user access to these
415 self.user_ns['_ih'] = self.input_hist
416 self.user_ns['_ih'] = self.input_hist
416 self.user_ns['_oh'] = self.output_hist
417 self.user_ns['_oh'] = self.output_hist
417 self.user_ns['_dh'] = self.dir_hist
418 self.user_ns['_dh'] = self.dir_hist
418
419
419 # user aliases to input and output histories
420 # user aliases to input and output histories
420 self.user_ns['In'] = self.input_hist
421 self.user_ns['In'] = self.input_hist
421 self.user_ns['Out'] = self.output_hist
422 self.user_ns['Out'] = self.output_hist
422
423
423 # Object variable to store code object waiting execution. This is
424 # Object variable to store code object waiting execution. This is
424 # used mainly by the multithreaded shells, but it can come in handy in
425 # used mainly by the multithreaded shells, but it can come in handy in
425 # other situations. No need to use a Queue here, since it's a single
426 # other situations. No need to use a Queue here, since it's a single
426 # item which gets cleared once run.
427 # item which gets cleared once run.
427 self.code_to_run = None
428 self.code_to_run = None
428
429
429 # Job manager (for jobs run as background threads)
430 # Job manager (for jobs run as background threads)
430 self.jobs = BackgroundJobManager()
431 self.jobs = BackgroundJobManager()
431 # Put the job manager into builtins so it's always there.
432 # Put the job manager into builtins so it's always there.
432 __builtin__.jobs = self.jobs
433 __builtin__.jobs = self.jobs
433
434
434 # escapes for automatic behavior on the command line
435 # escapes for automatic behavior on the command line
435 self.ESC_SHELL = '!'
436 self.ESC_SHELL = '!'
436 self.ESC_HELP = '?'
437 self.ESC_HELP = '?'
437 self.ESC_MAGIC = '%'
438 self.ESC_MAGIC = '%'
438 self.ESC_QUOTE = ','
439 self.ESC_QUOTE = ','
439 self.ESC_QUOTE2 = ';'
440 self.ESC_QUOTE2 = ';'
440 self.ESC_PAREN = '/'
441 self.ESC_PAREN = '/'
441
442
442 # And their associated handlers
443 # And their associated handlers
443 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
444 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
444 self.ESC_QUOTE : self.handle_auto,
445 self.ESC_QUOTE : self.handle_auto,
445 self.ESC_QUOTE2 : self.handle_auto,
446 self.ESC_QUOTE2 : self.handle_auto,
446 self.ESC_MAGIC : self.handle_magic,
447 self.ESC_MAGIC : self.handle_magic,
447 self.ESC_HELP : self.handle_help,
448 self.ESC_HELP : self.handle_help,
448 self.ESC_SHELL : self.handle_shell_escape,
449 self.ESC_SHELL : self.handle_shell_escape,
449 }
450 }
450
451
451 # class initializations
452 # class initializations
452 Magic.__init__(self,self)
453 Magic.__init__(self,self)
453
454
454 # Python source parser/formatter for syntax highlighting
455 # Python source parser/formatter for syntax highlighting
455 pyformat = PyColorize.Parser().format
456 pyformat = PyColorize.Parser().format
456 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
457 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
457
458
458 # hooks holds pointers used for user-side customizations
459 # hooks holds pointers used for user-side customizations
459 self.hooks = Struct()
460 self.hooks = Struct()
460
461
461 # Set all default hooks, defined in the IPython.hooks module.
462 # Set all default hooks, defined in the IPython.hooks module.
462 hooks = IPython.hooks
463 hooks = IPython.hooks
463 for hook_name in hooks.__all__:
464 for hook_name in hooks.__all__:
464 self.set_hook(hook_name,getattr(hooks,hook_name))
465 self.set_hook(hook_name,getattr(hooks,hook_name))
465
466
466 # Flag to mark unconditional exit
467 # Flag to mark unconditional exit
467 self.exit_now = False
468 self.exit_now = False
468
469
469 self.usage_min = """\
470 self.usage_min = """\
470 An enhanced console for Python.
471 An enhanced console for Python.
471 Some of its features are:
472 Some of its features are:
472 - Readline support if the readline library is present.
473 - Readline support if the readline library is present.
473 - Tab completion in the local namespace.
474 - Tab completion in the local namespace.
474 - Logging of input, see command-line options.
475 - Logging of input, see command-line options.
475 - System shell escape via ! , eg !ls.
476 - System shell escape via ! , eg !ls.
476 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
477 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
477 - Keeps track of locally defined variables via %who, %whos.
478 - Keeps track of locally defined variables via %who, %whos.
478 - Show object information with a ? eg ?x or x? (use ?? for more info).
479 - Show object information with a ? eg ?x or x? (use ?? for more info).
479 """
480 """
480 if usage: self.usage = usage
481 if usage: self.usage = usage
481 else: self.usage = self.usage_min
482 else: self.usage = self.usage_min
482
483
483 # Storage
484 # Storage
484 self.rc = rc # This will hold all configuration information
485 self.rc = rc # This will hold all configuration information
485 self.pager = 'less'
486 self.pager = 'less'
486 # temporary files used for various purposes. Deleted at exit.
487 # temporary files used for various purposes. Deleted at exit.
487 self.tempfiles = []
488 self.tempfiles = []
488
489
489 # Keep track of readline usage (later set by init_readline)
490 # Keep track of readline usage (later set by init_readline)
490 self.has_readline = False
491 self.has_readline = False
491
492
492 # template for logfile headers. It gets resolved at runtime by the
493 # template for logfile headers. It gets resolved at runtime by the
493 # logstart method.
494 # logstart method.
494 self.loghead_tpl = \
495 self.loghead_tpl = \
495 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
496 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
496 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
497 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
497 #log# opts = %s
498 #log# opts = %s
498 #log# args = %s
499 #log# args = %s
499 #log# It is safe to make manual edits below here.
500 #log# It is safe to make manual edits below here.
500 #log#-----------------------------------------------------------------------
501 #log#-----------------------------------------------------------------------
501 """
502 """
502 # for pushd/popd management
503 # for pushd/popd management
503 try:
504 try:
504 self.home_dir = get_home_dir()
505 self.home_dir = get_home_dir()
505 except HomeDirError,msg:
506 except HomeDirError,msg:
506 fatal(msg)
507 fatal(msg)
507
508
508 self.dir_stack = [os.getcwd().replace(self.home_dir,'~')]
509 self.dir_stack = [os.getcwd().replace(self.home_dir,'~')]
509
510
510 # Functions to call the underlying shell.
511 # Functions to call the underlying shell.
511
512
512 # utility to expand user variables via Itpl
513 # utility to expand user variables via Itpl
513 self.var_expand = lambda cmd: str(ItplNS(cmd.replace('#','\#'),
514 self.var_expand = lambda cmd: str(ItplNS(cmd.replace('#','\#'),
514 self.user_ns))
515 self.user_ns))
515 # The first is similar to os.system, but it doesn't return a value,
516 # The first is similar to os.system, but it doesn't return a value,
516 # and it allows interpolation of variables in the user's namespace.
517 # and it allows interpolation of variables in the user's namespace.
517 self.system = lambda cmd: shell(self.var_expand(cmd),
518 self.system = lambda cmd: shell(self.var_expand(cmd),
518 header='IPython system call: ',
519 header='IPython system call: ',
519 verbose=self.rc.system_verbose)
520 verbose=self.rc.system_verbose)
520 # These are for getoutput and getoutputerror:
521 # These are for getoutput and getoutputerror:
521 self.getoutput = lambda cmd: \
522 self.getoutput = lambda cmd: \
522 getoutput(self.var_expand(cmd),
523 getoutput(self.var_expand(cmd),
523 header='IPython system call: ',
524 header='IPython system call: ',
524 verbose=self.rc.system_verbose)
525 verbose=self.rc.system_verbose)
525 self.getoutputerror = lambda cmd: \
526 self.getoutputerror = lambda cmd: \
526 getoutputerror(str(ItplNS(cmd.replace('#','\#'),
527 getoutputerror(str(ItplNS(cmd.replace('#','\#'),
527 self.user_ns)),
528 self.user_ns)),
528 header='IPython system call: ',
529 header='IPython system call: ',
529 verbose=self.rc.system_verbose)
530 verbose=self.rc.system_verbose)
530
531
531 # RegExp for splitting line contents into pre-char//first
532 # RegExp for splitting line contents into pre-char//first
532 # word-method//rest. For clarity, each group in on one line.
533 # word-method//rest. For clarity, each group in on one line.
533
534
534 # WARNING: update the regexp if the above escapes are changed, as they
535 # WARNING: update the regexp if the above escapes are changed, as they
535 # are hardwired in.
536 # are hardwired in.
536
537
537 # Don't get carried away with trying to make the autocalling catch too
538 # Don't get carried away with trying to make the autocalling catch too
538 # much: it's better to be conservative rather than to trigger hidden
539 # much: it's better to be conservative rather than to trigger hidden
539 # evals() somewhere and end up causing side effects.
540 # evals() somewhere and end up causing side effects.
540
541
541 self.line_split = re.compile(r'^([\s*,;/])'
542 self.line_split = re.compile(r'^([\s*,;/])'
542 r'([\?\w\.]+\w*\s*)'
543 r'([\?\w\.]+\w*\s*)'
543 r'(\(?.*$)')
544 r'(\(?.*$)')
544
545
545 # Original re, keep around for a while in case changes break something
546 # Original re, keep around for a while in case changes break something
546 #self.line_split = re.compile(r'(^[\s*!\?%,/]?)'
547 #self.line_split = re.compile(r'(^[\s*!\?%,/]?)'
547 # r'(\s*[\?\w\.]+\w*\s*)'
548 # r'(\s*[\?\w\.]+\w*\s*)'
548 # r'(\(?.*$)')
549 # r'(\(?.*$)')
549
550
550 # RegExp to identify potential function names
551 # RegExp to identify potential function names
551 self.re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
552 self.re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
552 # RegExp to exclude strings with this start from autocalling
553 # RegExp to exclude strings with this start from autocalling
553 self.re_exclude_auto = re.compile('^[!=()<>,\*/\+-]|^is ')
554 self.re_exclude_auto = re.compile('^[!=()<>,\*/\+-]|^is ')
554
555
555 # try to catch also methods for stuff in lists/tuples/dicts: off
556 # try to catch also methods for stuff in lists/tuples/dicts: off
556 # (experimental). For this to work, the line_split regexp would need
557 # (experimental). For this to work, the line_split regexp would need
557 # to be modified so it wouldn't break things at '['. That line is
558 # to be modified so it wouldn't break things at '['. That line is
558 # nasty enough that I shouldn't change it until I can test it _well_.
559 # nasty enough that I shouldn't change it until I can test it _well_.
559 #self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
560 #self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
560
561
561 # keep track of where we started running (mainly for crash post-mortem)
562 # keep track of where we started running (mainly for crash post-mortem)
562 self.starting_dir = os.getcwd()
563 self.starting_dir = os.getcwd()
563
564
564 # Various switches which can be set
565 # Various switches which can be set
565 self.CACHELENGTH = 5000 # this is cheap, it's just text
566 self.CACHELENGTH = 5000 # this is cheap, it's just text
566 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
567 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
567 self.banner2 = banner2
568 self.banner2 = banner2
568
569
569 # TraceBack handlers:
570 # TraceBack handlers:
570
571
571 # Syntax error handler.
572 # Syntax error handler.
572 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
573 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
573
574
574 # The interactive one is initialized with an offset, meaning we always
575 # The interactive one is initialized with an offset, meaning we always
575 # want to remove the topmost item in the traceback, which is our own
576 # want to remove the topmost item in the traceback, which is our own
576 # internal code. Valid modes: ['Plain','Context','Verbose']
577 # internal code. Valid modes: ['Plain','Context','Verbose']
577 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
578 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
578 color_scheme='NoColor',
579 color_scheme='NoColor',
579 tb_offset = 1)
580 tb_offset = 1)
580
581
581 # IPython itself shouldn't crash. This will produce a detailed
582 # IPython itself shouldn't crash. This will produce a detailed
582 # post-mortem if it does. But we only install the crash handler for
583 # post-mortem if it does. But we only install the crash handler for
583 # non-threaded shells, the threaded ones use a normal verbose reporter
584 # non-threaded shells, the threaded ones use a normal verbose reporter
584 # and lose the crash handler. This is because exceptions in the main
585 # and lose the crash handler. This is because exceptions in the main
585 # thread (such as in GUI code) propagate directly to sys.excepthook,
586 # thread (such as in GUI code) propagate directly to sys.excepthook,
586 # and there's no point in printing crash dumps for every user exception.
587 # and there's no point in printing crash dumps for every user exception.
587 if self.isthreaded:
588 if self.isthreaded:
588 sys.excepthook = ultraTB.FormattedTB()
589 sys.excepthook = ultraTB.FormattedTB()
589 else:
590 else:
590 from IPython import CrashHandler
591 from IPython import CrashHandler
591 sys.excepthook = CrashHandler.CrashHandler(self)
592 sys.excepthook = CrashHandler.CrashHandler(self)
592
593
593 # The instance will store a pointer to this, so that runtime code
594 # The instance will store a pointer to this, so that runtime code
594 # (such as magics) can access it. This is because during the
595 # (such as magics) can access it. This is because during the
595 # read-eval loop, it gets temporarily overwritten (to deal with GUI
596 # read-eval loop, it gets temporarily overwritten (to deal with GUI
596 # frameworks).
597 # frameworks).
597 self.sys_excepthook = sys.excepthook
598 self.sys_excepthook = sys.excepthook
598
599
599 # and add any custom exception handlers the user may have specified
600 # and add any custom exception handlers the user may have specified
600 self.set_custom_exc(*custom_exceptions)
601 self.set_custom_exc(*custom_exceptions)
601
602
602 # Object inspector
603 # Object inspector
603 self.inspector = OInspect.Inspector(OInspect.InspectColors,
604 self.inspector = OInspect.Inspector(OInspect.InspectColors,
604 PyColorize.ANSICodeColors,
605 PyColorize.ANSICodeColors,
605 'NoColor')
606 'NoColor')
606 # indentation management
607 # indentation management
607 self.autoindent = False
608 self.autoindent = False
608 self.indent_current_nsp = 0
609 self.indent_current_nsp = 0
609 self.indent_current = '' # actual indent string
610 self.indent_current = '' # actual indent string
610
611
611 # Make some aliases automatically
612 # Make some aliases automatically
612 # Prepare list of shell aliases to auto-define
613 # Prepare list of shell aliases to auto-define
613 if os.name == 'posix':
614 if os.name == 'posix':
614 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
615 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
615 'mv mv -i','rm rm -i','cp cp -i',
616 'mv mv -i','rm rm -i','cp cp -i',
616 'cat cat','less less','clear clear',
617 'cat cat','less less','clear clear',
617 # a better ls
618 # a better ls
618 'ls ls -F',
619 'ls ls -F',
619 # long ls
620 # long ls
620 'll ls -lF',
621 'll ls -lF',
621 # color ls
622 # color ls
622 'lc ls -F -o --color',
623 'lc ls -F -o --color',
623 # ls normal files only
624 # ls normal files only
624 'lf ls -F -o --color %l | grep ^-',
625 'lf ls -F -o --color %l | grep ^-',
625 # ls symbolic links
626 # ls symbolic links
626 'lk ls -F -o --color %l | grep ^l',
627 'lk ls -F -o --color %l | grep ^l',
627 # directories or links to directories,
628 # directories or links to directories,
628 'ldir ls -F -o --color %l | grep /$',
629 'ldir ls -F -o --color %l | grep /$',
629 # things which are executable
630 # things which are executable
630 'lx ls -F -o --color %l | grep ^-..x',
631 'lx ls -F -o --color %l | grep ^-..x',
631 )
632 )
632 elif os.name in ['nt','dos']:
633 elif os.name in ['nt','dos']:
633 auto_alias = ('dir dir /on', 'ls dir /on',
634 auto_alias = ('dir dir /on', 'ls dir /on',
634 'ddir dir /ad /on', 'ldir dir /ad /on',
635 'ddir dir /ad /on', 'ldir dir /ad /on',
635 'mkdir mkdir','rmdir rmdir','echo echo',
636 'mkdir mkdir','rmdir rmdir','echo echo',
636 'ren ren','cls cls','copy copy')
637 'ren ren','cls cls','copy copy')
637 else:
638 else:
638 auto_alias = ()
639 auto_alias = ()
639 self.auto_alias = map(lambda s:s.split(None,1),auto_alias)
640 self.auto_alias = map(lambda s:s.split(None,1),auto_alias)
640 # Call the actual (public) initializer
641 # Call the actual (public) initializer
641 self.init_auto_alias()
642 self.init_auto_alias()
642 # end __init__
643 # end __init__
643
644
644 def post_config_initialization(self):
645 def post_config_initialization(self):
645 """Post configuration init method
646 """Post configuration init method
646
647
647 This is called after the configuration files have been processed to
648 This is called after the configuration files have been processed to
648 'finalize' the initialization."""
649 'finalize' the initialization."""
649
650
650 rc = self.rc
651 rc = self.rc
651
652
652 # Load readline proper
653 # Load readline proper
653 if rc.readline:
654 if rc.readline:
654 self.init_readline()
655 self.init_readline()
655
656
656 # log system
657 # log system
657 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
658 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
658 # local shortcut, this is used a LOT
659 # local shortcut, this is used a LOT
659 self.log = self.logger.log
660 self.log = self.logger.log
660
661
661 # Initialize cache, set in/out prompts and printing system
662 # Initialize cache, set in/out prompts and printing system
662 self.outputcache = CachedOutput(self,
663 self.outputcache = CachedOutput(self,
663 rc.cache_size,
664 rc.cache_size,
664 rc.pprint,
665 rc.pprint,
665 input_sep = rc.separate_in,
666 input_sep = rc.separate_in,
666 output_sep = rc.separate_out,
667 output_sep = rc.separate_out,
667 output_sep2 = rc.separate_out2,
668 output_sep2 = rc.separate_out2,
668 ps1 = rc.prompt_in1,
669 ps1 = rc.prompt_in1,
669 ps2 = rc.prompt_in2,
670 ps2 = rc.prompt_in2,
670 ps_out = rc.prompt_out,
671 ps_out = rc.prompt_out,
671 pad_left = rc.prompts_pad_left)
672 pad_left = rc.prompts_pad_left)
672
673
673 # user may have over-ridden the default print hook:
674 # user may have over-ridden the default print hook:
674 try:
675 try:
675 self.outputcache.__class__.display = self.hooks.display
676 self.outputcache.__class__.display = self.hooks.display
676 except AttributeError:
677 except AttributeError:
677 pass
678 pass
678
679
679 # I don't like assigning globally to sys, because it means when embedding
680 # I don't like assigning globally to sys, because it means when embedding
680 # instances, each embedded instance overrides the previous choice. But
681 # instances, each embedded instance overrides the previous choice. But
681 # sys.displayhook seems to be called internally by exec, so I don't see a
682 # sys.displayhook seems to be called internally by exec, so I don't see a
682 # way around it.
683 # way around it.
683 sys.displayhook = self.outputcache
684 sys.displayhook = self.outputcache
684
685
685 # Set user colors (don't do it in the constructor above so that it
686 # Set user colors (don't do it in the constructor above so that it
686 # doesn't crash if colors option is invalid)
687 # doesn't crash if colors option is invalid)
687 self.magic_colors(rc.colors)
688 self.magic_colors(rc.colors)
688
689
689 # Set calling of pdb on exceptions
690 # Set calling of pdb on exceptions
690 self.call_pdb = rc.pdb
691 self.call_pdb = rc.pdb
691
692
692 # Load user aliases
693 # Load user aliases
693 for alias in rc.alias:
694 for alias in rc.alias:
694 self.magic_alias(alias)
695 self.magic_alias(alias)
695
696
696 # dynamic data that survives through sessions
697 # dynamic data that survives through sessions
697 # XXX make the filename a config option?
698 # XXX make the filename a config option?
698 persist_base = 'persist'
699 persist_base = 'persist'
699 if rc.profile:
700 if rc.profile:
700 persist_base += '_%s' % rc.profile
701 persist_base += '_%s' % rc.profile
701 self.persist_fname = os.path.join(rc.ipythondir,persist_base)
702 self.persist_fname = os.path.join(rc.ipythondir,persist_base)
702
703
703 try:
704 try:
704 self.persist = pickle.load(file(self.persist_fname))
705 self.persist = pickle.load(file(self.persist_fname))
705 except:
706 except:
706 self.persist = {}
707 self.persist = {}
707
708
708
709
709 for (key, value) in [(k[2:],v) for (k,v) in self.persist.items() if k.startswith('S:')]:
710 for (key, value) in [(k[2:],v) for (k,v) in self.persist.items() if k.startswith('S:')]:
710 try:
711 try:
711 obj = pickle.loads(value)
712 obj = pickle.loads(value)
712 except:
713 except:
713
714
714 print "Unable to restore variable '%s', ignoring (use %%store -d to forget!)" % key
715 print "Unable to restore variable '%s', ignoring (use %%store -d to forget!)" % key
715 print "The error was:",sys.exc_info()[0]
716 print "The error was:",sys.exc_info()[0]
716 continue
717 continue
717
718
718
719
719 self.user_ns[key] = obj
720 self.user_ns[key] = obj
720
721
721
722
723
724 def set_hook(self,name,hook):
722 def set_hook(self,name,hook):
725 """set_hook(name,hook) -> sets an internal IPython hook.
723 """set_hook(name,hook) -> sets an internal IPython hook.
726
724
727 IPython exposes some of its internal API as user-modifiable hooks. By
725 IPython exposes some of its internal API as user-modifiable hooks. By
728 resetting one of these hooks, you can modify IPython's behavior to
726 resetting one of these hooks, you can modify IPython's behavior to
729 call at runtime your own routines."""
727 call at runtime your own routines."""
730
728
731 # At some point in the future, this should validate the hook before it
729 # At some point in the future, this should validate the hook before it
732 # accepts it. Probably at least check that the hook takes the number
730 # accepts it. Probably at least check that the hook takes the number
733 # of args it's supposed to.
731 # of args it's supposed to.
734 setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
732 setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
735
733
736 def set_custom_exc(self,exc_tuple,handler):
734 def set_custom_exc(self,exc_tuple,handler):
737 """set_custom_exc(exc_tuple,handler)
735 """set_custom_exc(exc_tuple,handler)
738
736
739 Set a custom exception handler, which will be called if any of the
737 Set a custom exception handler, which will be called if any of the
740 exceptions in exc_tuple occur in the mainloop (specifically, in the
738 exceptions in exc_tuple occur in the mainloop (specifically, in the
741 runcode() method.
739 runcode() method.
742
740
743 Inputs:
741 Inputs:
744
742
745 - exc_tuple: a *tuple* of valid exceptions to call the defined
743 - exc_tuple: a *tuple* of valid exceptions to call the defined
746 handler for. It is very important that you use a tuple, and NOT A
744 handler for. It is very important that you use a tuple, and NOT A
747 LIST here, because of the way Python's except statement works. If
745 LIST here, because of the way Python's except statement works. If
748 you only want to trap a single exception, use a singleton tuple:
746 you only want to trap a single exception, use a singleton tuple:
749
747
750 exc_tuple == (MyCustomException,)
748 exc_tuple == (MyCustomException,)
751
749
752 - handler: this must be defined as a function with the following
750 - handler: this must be defined as a function with the following
753 basic interface: def my_handler(self,etype,value,tb).
751 basic interface: def my_handler(self,etype,value,tb).
754
752
755 This will be made into an instance method (via new.instancemethod)
753 This will be made into an instance method (via new.instancemethod)
756 of IPython itself, and it will be called if any of the exceptions
754 of IPython itself, and it will be called if any of the exceptions
757 listed in the exc_tuple are caught. If the handler is None, an
755 listed in the exc_tuple are caught. If the handler is None, an
758 internal basic one is used, which just prints basic info.
756 internal basic one is used, which just prints basic info.
759
757
760 WARNING: by putting in your own exception handler into IPython's main
758 WARNING: by putting in your own exception handler into IPython's main
761 execution loop, you run a very good chance of nasty crashes. This
759 execution loop, you run a very good chance of nasty crashes. This
762 facility should only be used if you really know what you are doing."""
760 facility should only be used if you really know what you are doing."""
763
761
764 assert type(exc_tuple)==type(()) , \
762 assert type(exc_tuple)==type(()) , \
765 "The custom exceptions must be given AS A TUPLE."
763 "The custom exceptions must be given AS A TUPLE."
766
764
767 def dummy_handler(self,etype,value,tb):
765 def dummy_handler(self,etype,value,tb):
768 print '*** Simple custom exception handler ***'
766 print '*** Simple custom exception handler ***'
769 print 'Exception type :',etype
767 print 'Exception type :',etype
770 print 'Exception value:',value
768 print 'Exception value:',value
771 print 'Traceback :',tb
769 print 'Traceback :',tb
772 print 'Source code :','\n'.join(self.buffer)
770 print 'Source code :','\n'.join(self.buffer)
773
771
774 if handler is None: handler = dummy_handler
772 if handler is None: handler = dummy_handler
775
773
776 self.CustomTB = new.instancemethod(handler,self,self.__class__)
774 self.CustomTB = new.instancemethod(handler,self,self.__class__)
777 self.custom_exceptions = exc_tuple
775 self.custom_exceptions = exc_tuple
778
776
779 def set_custom_completer(self,completer,pos=0):
777 def set_custom_completer(self,completer,pos=0):
780 """set_custom_completer(completer,pos=0)
778 """set_custom_completer(completer,pos=0)
781
779
782 Adds a new custom completer function.
780 Adds a new custom completer function.
783
781
784 The position argument (defaults to 0) is the index in the completers
782 The position argument (defaults to 0) is the index in the completers
785 list where you want the completer to be inserted."""
783 list where you want the completer to be inserted."""
786
784
787 newcomp = new.instancemethod(completer,self.Completer,
785 newcomp = new.instancemethod(completer,self.Completer,
788 self.Completer.__class__)
786 self.Completer.__class__)
789 self.Completer.matchers.insert(pos,newcomp)
787 self.Completer.matchers.insert(pos,newcomp)
790
788
791 def _get_call_pdb(self):
789 def _get_call_pdb(self):
792 return self._call_pdb
790 return self._call_pdb
793
791
794 def _set_call_pdb(self,val):
792 def _set_call_pdb(self,val):
795
793
796 if val not in (0,1,False,True):
794 if val not in (0,1,False,True):
797 raise ValueError,'new call_pdb value must be boolean'
795 raise ValueError,'new call_pdb value must be boolean'
798
796
799 # store value in instance
797 # store value in instance
800 self._call_pdb = val
798 self._call_pdb = val
801
799
802 # notify the actual exception handlers
800 # notify the actual exception handlers
803 self.InteractiveTB.call_pdb = val
801 self.InteractiveTB.call_pdb = val
804 if self.isthreaded:
802 if self.isthreaded:
805 try:
803 try:
806 self.sys_excepthook.call_pdb = val
804 self.sys_excepthook.call_pdb = val
807 except:
805 except:
808 warn('Failed to activate pdb for threaded exception handler')
806 warn('Failed to activate pdb for threaded exception handler')
809
807
810 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
808 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
811 'Control auto-activation of pdb at exceptions')
809 'Control auto-activation of pdb at exceptions')
812
810
813 def complete(self,text):
811 def complete(self,text):
814 """Return a sorted list of all possible completions on text.
812 """Return a sorted list of all possible completions on text.
815
813
816 Inputs:
814 Inputs:
817
815
818 - text: a string of text to be completed on.
816 - text: a string of text to be completed on.
819
817
820 This is a wrapper around the completion mechanism, similar to what
818 This is a wrapper around the completion mechanism, similar to what
821 readline does at the command line when the TAB key is hit. By
819 readline does at the command line when the TAB key is hit. By
822 exposing it as a method, it can be used by other non-readline
820 exposing it as a method, it can be used by other non-readline
823 environments (such as GUIs) for text completion.
821 environments (such as GUIs) for text completion.
824
822
825 Simple usage example:
823 Simple usage example:
826
824
827 In [1]: x = 'hello'
825 In [1]: x = 'hello'
828
826
829 In [2]: __IP.complete('x.l')
827 In [2]: __IP.complete('x.l')
830 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
828 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
831
829
832 complete = self.Completer.complete
830 complete = self.Completer.complete
833 state = 0
831 state = 0
834 # use a dict so we get unique keys, since ipyhton's multiple
832 # use a dict so we get unique keys, since ipyhton's multiple
835 # completers can return duplicates.
833 # completers can return duplicates.
836 comps = {}
834 comps = {}
837 while True:
835 while True:
838 newcomp = complete(text,state)
836 newcomp = complete(text,state)
839 if newcomp is None:
837 if newcomp is None:
840 break
838 break
841 comps[newcomp] = 1
839 comps[newcomp] = 1
842 state += 1
840 state += 1
843 outcomps = comps.keys()
841 outcomps = comps.keys()
844 outcomps.sort()
842 outcomps.sort()
845 return outcomps
843 return outcomps
846
844
847 def set_completer_frame(self, frame):
845 def set_completer_frame(self, frame):
848 if frame:
846 if frame:
849 self.Completer.namespace = frame.f_locals
847 self.Completer.namespace = frame.f_locals
850 self.Completer.global_namespace = frame.f_globals
848 self.Completer.global_namespace = frame.f_globals
851 else:
849 else:
852 self.Completer.namespace = self.user_ns
850 self.Completer.namespace = self.user_ns
853 self.Completer.global_namespace = self.user_global_ns
851 self.Completer.global_namespace = self.user_global_ns
854
852
855 def init_auto_alias(self):
853 def init_auto_alias(self):
856 """Define some aliases automatically.
854 """Define some aliases automatically.
857
855
858 These are ALL parameter-less aliases"""
856 These are ALL parameter-less aliases"""
859 for alias,cmd in self.auto_alias:
857 for alias,cmd in self.auto_alias:
860 self.alias_table[alias] = (0,cmd)
858 self.alias_table[alias] = (0,cmd)
861
859
862 def alias_table_validate(self,verbose=0):
860 def alias_table_validate(self,verbose=0):
863 """Update information about the alias table.
861 """Update information about the alias table.
864
862
865 In particular, make sure no Python keywords/builtins are in it."""
863 In particular, make sure no Python keywords/builtins are in it."""
866
864
867 no_alias = self.no_alias
865 no_alias = self.no_alias
868 for k in self.alias_table.keys():
866 for k in self.alias_table.keys():
869 if k in no_alias:
867 if k in no_alias:
870 del self.alias_table[k]
868 del self.alias_table[k]
871 if verbose:
869 if verbose:
872 print ("Deleting alias <%s>, it's a Python "
870 print ("Deleting alias <%s>, it's a Python "
873 "keyword or builtin." % k)
871 "keyword or builtin." % k)
874
872
875 def set_autoindent(self,value=None):
873 def set_autoindent(self,value=None):
876 """Set the autoindent flag, checking for readline support.
874 """Set the autoindent flag, checking for readline support.
877
875
878 If called with no arguments, it acts as a toggle."""
876 If called with no arguments, it acts as a toggle."""
879
877
880 if not self.has_readline:
878 if not self.has_readline:
881 if os.name == 'posix':
879 if os.name == 'posix':
882 warn("The auto-indent feature requires the readline library")
880 warn("The auto-indent feature requires the readline library")
883 self.autoindent = 0
881 self.autoindent = 0
884 return
882 return
885 if value is None:
883 if value is None:
886 self.autoindent = not self.autoindent
884 self.autoindent = not self.autoindent
887 else:
885 else:
888 self.autoindent = value
886 self.autoindent = value
889
887
890 def rc_set_toggle(self,rc_field,value=None):
888 def rc_set_toggle(self,rc_field,value=None):
891 """Set or toggle a field in IPython's rc config. structure.
889 """Set or toggle a field in IPython's rc config. structure.
892
890
893 If called with no arguments, it acts as a toggle.
891 If called with no arguments, it acts as a toggle.
894
892
895 If called with a non-existent field, the resulting AttributeError
893 If called with a non-existent field, the resulting AttributeError
896 exception will propagate out."""
894 exception will propagate out."""
897
895
898 rc_val = getattr(self.rc,rc_field)
896 rc_val = getattr(self.rc,rc_field)
899 if value is None:
897 if value is None:
900 value = not rc_val
898 value = not rc_val
901 setattr(self.rc,rc_field,value)
899 setattr(self.rc,rc_field,value)
902
900
903 def user_setup(self,ipythondir,rc_suffix,mode='install'):
901 def user_setup(self,ipythondir,rc_suffix,mode='install'):
904 """Install the user configuration directory.
902 """Install the user configuration directory.
905
903
906 Can be called when running for the first time or to upgrade the user's
904 Can be called when running for the first time or to upgrade the user's
907 .ipython/ directory with the mode parameter. Valid modes are 'install'
905 .ipython/ directory with the mode parameter. Valid modes are 'install'
908 and 'upgrade'."""
906 and 'upgrade'."""
909
907
910 def wait():
908 def wait():
911 try:
909 try:
912 raw_input("Please press <RETURN> to start IPython.")
910 raw_input("Please press <RETURN> to start IPython.")
913 except EOFError:
911 except EOFError:
914 print >> Term.cout
912 print >> Term.cout
915 print '*'*70
913 print '*'*70
916
914
917 cwd = os.getcwd() # remember where we started
915 cwd = os.getcwd() # remember where we started
918 glb = glob.glob
916 glb = glob.glob
919 print '*'*70
917 print '*'*70
920 if mode == 'install':
918 if mode == 'install':
921 print \
919 print \
922 """Welcome to IPython. I will try to create a personal configuration directory
920 """Welcome to IPython. I will try to create a personal configuration directory
923 where you can customize many aspects of IPython's functionality in:\n"""
921 where you can customize many aspects of IPython's functionality in:\n"""
924 else:
922 else:
925 print 'I am going to upgrade your configuration in:'
923 print 'I am going to upgrade your configuration in:'
926
924
927 print ipythondir
925 print ipythondir
928
926
929 rcdirend = os.path.join('IPython','UserConfig')
927 rcdirend = os.path.join('IPython','UserConfig')
930 cfg = lambda d: os.path.join(d,rcdirend)
928 cfg = lambda d: os.path.join(d,rcdirend)
931 try:
929 try:
932 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
930 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
933 except IOError:
931 except IOError:
934 warning = """
932 warning = """
935 Installation error. IPython's directory was not found.
933 Installation error. IPython's directory was not found.
936
934
937 Check the following:
935 Check the following:
938
936
939 The ipython/IPython directory should be in a directory belonging to your
937 The ipython/IPython directory should be in a directory belonging to your
940 PYTHONPATH environment variable (that is, it should be in a directory
938 PYTHONPATH environment variable (that is, it should be in a directory
941 belonging to sys.path). You can copy it explicitly there or just link to it.
939 belonging to sys.path). You can copy it explicitly there or just link to it.
942
940
943 IPython will proceed with builtin defaults.
941 IPython will proceed with builtin defaults.
944 """
942 """
945 warn(warning)
943 warn(warning)
946 wait()
944 wait()
947 return
945 return
948
946
949 if mode == 'install':
947 if mode == 'install':
950 try:
948 try:
951 shutil.copytree(rcdir,ipythondir)
949 shutil.copytree(rcdir,ipythondir)
952 os.chdir(ipythondir)
950 os.chdir(ipythondir)
953 rc_files = glb("ipythonrc*")
951 rc_files = glb("ipythonrc*")
954 for rc_file in rc_files:
952 for rc_file in rc_files:
955 os.rename(rc_file,rc_file+rc_suffix)
953 os.rename(rc_file,rc_file+rc_suffix)
956 except:
954 except:
957 warning = """
955 warning = """
958
956
959 There was a problem with the installation:
957 There was a problem with the installation:
960 %s
958 %s
961 Try to correct it or contact the developers if you think it's a bug.
959 Try to correct it or contact the developers if you think it's a bug.
962 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
960 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
963 warn(warning)
961 warn(warning)
964 wait()
962 wait()
965 return
963 return
966
964
967 elif mode == 'upgrade':
965 elif mode == 'upgrade':
968 try:
966 try:
969 os.chdir(ipythondir)
967 os.chdir(ipythondir)
970 except:
968 except:
971 print """
969 print """
972 Can not upgrade: changing to directory %s failed. Details:
970 Can not upgrade: changing to directory %s failed. Details:
973 %s
971 %s
974 """ % (ipythondir,sys.exc_info()[1])
972 """ % (ipythondir,sys.exc_info()[1])
975 wait()
973 wait()
976 return
974 return
977 else:
975 else:
978 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
976 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
979 for new_full_path in sources:
977 for new_full_path in sources:
980 new_filename = os.path.basename(new_full_path)
978 new_filename = os.path.basename(new_full_path)
981 if new_filename.startswith('ipythonrc'):
979 if new_filename.startswith('ipythonrc'):
982 new_filename = new_filename + rc_suffix
980 new_filename = new_filename + rc_suffix
983 # The config directory should only contain files, skip any
981 # The config directory should only contain files, skip any
984 # directories which may be there (like CVS)
982 # directories which may be there (like CVS)
985 if os.path.isdir(new_full_path):
983 if os.path.isdir(new_full_path):
986 continue
984 continue
987 if os.path.exists(new_filename):
985 if os.path.exists(new_filename):
988 old_file = new_filename+'.old'
986 old_file = new_filename+'.old'
989 if os.path.exists(old_file):
987 if os.path.exists(old_file):
990 os.remove(old_file)
988 os.remove(old_file)
991 os.rename(new_filename,old_file)
989 os.rename(new_filename,old_file)
992 shutil.copy(new_full_path,new_filename)
990 shutil.copy(new_full_path,new_filename)
993 else:
991 else:
994 raise ValueError,'unrecognized mode for install:',`mode`
992 raise ValueError,'unrecognized mode for install:',`mode`
995
993
996 # Fix line-endings to those native to each platform in the config
994 # Fix line-endings to those native to each platform in the config
997 # directory.
995 # directory.
998 try:
996 try:
999 os.chdir(ipythondir)
997 os.chdir(ipythondir)
1000 except:
998 except:
1001 print """
999 print """
1002 Problem: changing to directory %s failed.
1000 Problem: changing to directory %s failed.
1003 Details:
1001 Details:
1004 %s
1002 %s
1005
1003
1006 Some configuration files may have incorrect line endings. This should not
1004 Some configuration files may have incorrect line endings. This should not
1007 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
1005 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
1008 wait()
1006 wait()
1009 else:
1007 else:
1010 for fname in glb('ipythonrc*'):
1008 for fname in glb('ipythonrc*'):
1011 try:
1009 try:
1012 native_line_ends(fname,backup=0)
1010 native_line_ends(fname,backup=0)
1013 except IOError:
1011 except IOError:
1014 pass
1012 pass
1015
1013
1016 if mode == 'install':
1014 if mode == 'install':
1017 print """
1015 print """
1018 Successful installation!
1016 Successful installation!
1019
1017
1020 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
1018 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
1021 IPython manual (there are both HTML and PDF versions supplied with the
1019 IPython manual (there are both HTML and PDF versions supplied with the
1022 distribution) to make sure that your system environment is properly configured
1020 distribution) to make sure that your system environment is properly configured
1023 to take advantage of IPython's features."""
1021 to take advantage of IPython's features."""
1024 else:
1022 else:
1025 print """
1023 print """
1026 Successful upgrade!
1024 Successful upgrade!
1027
1025
1028 All files in your directory:
1026 All files in your directory:
1029 %(ipythondir)s
1027 %(ipythondir)s
1030 which would have been overwritten by the upgrade were backed up with a .old
1028 which would have been overwritten by the upgrade were backed up with a .old
1031 extension. If you had made particular customizations in those files you may
1029 extension. If you had made particular customizations in those files you may
1032 want to merge them back into the new files.""" % locals()
1030 want to merge them back into the new files.""" % locals()
1033 wait()
1031 wait()
1034 os.chdir(cwd)
1032 os.chdir(cwd)
1035 # end user_setup()
1033 # end user_setup()
1036
1034
1037 def atexit_operations(self):
1035 def atexit_operations(self):
1038 """This will be executed at the time of exit.
1036 """This will be executed at the time of exit.
1039
1037
1040 Saving of persistent data should be performed here. """
1038 Saving of persistent data should be performed here. """
1041
1039
1042 # input history
1040 # input history
1043 self.savehist()
1041 self.savehist()
1044
1042
1045 # Cleanup all tempfiles left around
1043 # Cleanup all tempfiles left around
1046 for tfile in self.tempfiles:
1044 for tfile in self.tempfiles:
1047 try:
1045 try:
1048 os.unlink(tfile)
1046 os.unlink(tfile)
1049 except OSError:
1047 except OSError:
1050 pass
1048 pass
1051
1049
1052 # save the "persistent data" catch-all dictionary
1050 # save the "persistent data" catch-all dictionary
1053 try:
1051 try:
1054 pickle.dump(self.persist, open(self.persist_fname,"w"))
1052 pickle.dump(self.persist, open(self.persist_fname,"w"))
1055 except:
1053 except:
1056 print "*** ERROR *** persistent data saving failed."
1054 print "*** ERROR *** persistent data saving failed."
1057
1055
1058 def savehist(self):
1056 def savehist(self):
1059 """Save input history to a file (via readline library)."""
1057 """Save input history to a file (via readline library)."""
1060 try:
1058 try:
1061 self.readline.write_history_file(self.histfile)
1059 self.readline.write_history_file(self.histfile)
1062 except:
1060 except:
1063 print 'Unable to save IPython command history to file: ' + \
1061 print 'Unable to save IPython command history to file: ' + \
1064 `self.histfile`
1062 `self.histfile`
1065
1063
1066 def pre_readline(self):
1064 def pre_readline(self):
1067 """readline hook to be used at the start of each line.
1065 """readline hook to be used at the start of each line.
1068
1066
1069 Currently it handles auto-indent only."""
1067 Currently it handles auto-indent only."""
1070
1068
1071 self.readline.insert_text(self.indent_current)
1069 self.readline.insert_text(self.indent_current)
1072
1070
1073 def init_readline(self):
1071 def init_readline(self):
1074 """Command history completion/saving/reloading."""
1072 """Command history completion/saving/reloading."""
1075 try:
1073 try:
1076 import readline
1074 import readline
1077 except ImportError:
1075 except ImportError:
1078 self.has_readline = 0
1076 self.has_readline = 0
1079 self.readline = None
1077 self.readline = None
1080 # no point in bugging windows users with this every time:
1078 # no point in bugging windows users with this every time:
1081 if os.name == 'posix':
1079 if os.name == 'posix':
1082 warn('Readline services not available on this platform.')
1080 warn('Readline services not available on this platform.')
1083 else:
1081 else:
1084 import atexit
1082 import atexit
1085 from IPython.completer import IPCompleter
1083 from IPython.completer import IPCompleter
1086 self.Completer = IPCompleter(self,
1084 self.Completer = IPCompleter(self,
1087 self.user_ns,
1085 self.user_ns,
1088 self.user_global_ns,
1086 self.user_global_ns,
1089 self.rc.readline_omit__names,
1087 self.rc.readline_omit__names,
1090 self.alias_table)
1088 self.alias_table)
1091
1089
1092 # Platform-specific configuration
1090 # Platform-specific configuration
1093 if os.name == 'nt':
1091 if os.name == 'nt':
1094 self.readline_startup_hook = readline.set_pre_input_hook
1092 self.readline_startup_hook = readline.set_pre_input_hook
1095 else:
1093 else:
1096 self.readline_startup_hook = readline.set_startup_hook
1094 self.readline_startup_hook = readline.set_startup_hook
1097
1095
1098 # Load user's initrc file (readline config)
1096 # Load user's initrc file (readline config)
1099 inputrc_name = os.environ.get('INPUTRC')
1097 inputrc_name = os.environ.get('INPUTRC')
1100 if inputrc_name is None:
1098 if inputrc_name is None:
1101 home_dir = get_home_dir()
1099 home_dir = get_home_dir()
1102 if home_dir is not None:
1100 if home_dir is not None:
1103 inputrc_name = os.path.join(home_dir,'.inputrc')
1101 inputrc_name = os.path.join(home_dir,'.inputrc')
1104 if os.path.isfile(inputrc_name):
1102 if os.path.isfile(inputrc_name):
1105 try:
1103 try:
1106 readline.read_init_file(inputrc_name)
1104 readline.read_init_file(inputrc_name)
1107 except:
1105 except:
1108 warn('Problems reading readline initialization file <%s>'
1106 warn('Problems reading readline initialization file <%s>'
1109 % inputrc_name)
1107 % inputrc_name)
1110
1108
1111 self.has_readline = 1
1109 self.has_readline = 1
1112 self.readline = readline
1110 self.readline = readline
1113 # save this in sys so embedded copies can restore it properly
1111 # save this in sys so embedded copies can restore it properly
1114 sys.ipcompleter = self.Completer.complete
1112 sys.ipcompleter = self.Completer.complete
1115 readline.set_completer(self.Completer.complete)
1113 readline.set_completer(self.Completer.complete)
1116
1114
1117 # Configure readline according to user's prefs
1115 # Configure readline according to user's prefs
1118 for rlcommand in self.rc.readline_parse_and_bind:
1116 for rlcommand in self.rc.readline_parse_and_bind:
1119 readline.parse_and_bind(rlcommand)
1117 readline.parse_and_bind(rlcommand)
1120
1118
1121 # remove some chars from the delimiters list
1119 # remove some chars from the delimiters list
1122 delims = readline.get_completer_delims()
1120 delims = readline.get_completer_delims()
1123 delims = delims.translate(string._idmap,
1121 delims = delims.translate(string._idmap,
1124 self.rc.readline_remove_delims)
1122 self.rc.readline_remove_delims)
1125 readline.set_completer_delims(delims)
1123 readline.set_completer_delims(delims)
1126 # otherwise we end up with a monster history after a while:
1124 # otherwise we end up with a monster history after a while:
1127 readline.set_history_length(1000)
1125 readline.set_history_length(1000)
1128 try:
1126 try:
1129 #print '*** Reading readline history' # dbg
1127 #print '*** Reading readline history' # dbg
1130 readline.read_history_file(self.histfile)
1128 readline.read_history_file(self.histfile)
1131 except IOError:
1129 except IOError:
1132 pass # It doesn't exist yet.
1130 pass # It doesn't exist yet.
1133
1131
1134 atexit.register(self.atexit_operations)
1132 atexit.register(self.atexit_operations)
1135 del atexit
1133 del atexit
1136
1134
1137 # Configure auto-indent for all platforms
1135 # Configure auto-indent for all platforms
1138 self.set_autoindent(self.rc.autoindent)
1136 self.set_autoindent(self.rc.autoindent)
1139
1137
1140 def _should_recompile(self,e):
1138 def _should_recompile(self,e):
1141 """Utility routine for edit_syntax_error"""
1139 """Utility routine for edit_syntax_error"""
1142
1140
1143 if e.filename in ('<ipython console>','<input>','<string>',
1141 if e.filename in ('<ipython console>','<input>','<string>',
1144 '<console>'):
1142 '<console>'):
1145 return False
1143 return False
1146 try:
1144 try:
1147 if not ask_yes_no('Return to editor to correct syntax error? '
1145 if not ask_yes_no('Return to editor to correct syntax error? '
1148 '[Y/n] ','y'):
1146 '[Y/n] ','y'):
1149 return False
1147 return False
1150 except EOFError:
1148 except EOFError:
1151 return False
1149 return False
1152 self.hooks.fix_error_editor(e.filename,e.lineno,e.offset,e.msg)
1150 self.hooks.fix_error_editor(e.filename,e.lineno,e.offset,e.msg)
1153 return True
1151 return True
1154
1152
1155 def edit_syntax_error(self):
1153 def edit_syntax_error(self):
1156 """The bottom half of the syntax error handler called in the main loop.
1154 """The bottom half of the syntax error handler called in the main loop.
1157
1155
1158 Loop until syntax error is fixed or user cancels.
1156 Loop until syntax error is fixed or user cancels.
1159 """
1157 """
1160
1158
1161 while self.SyntaxTB.last_syntax_error:
1159 while self.SyntaxTB.last_syntax_error:
1162 # copy and clear last_syntax_error
1160 # copy and clear last_syntax_error
1163 err = self.SyntaxTB.clear_err_state()
1161 err = self.SyntaxTB.clear_err_state()
1164 if not self._should_recompile(err):
1162 if not self._should_recompile(err):
1165 return
1163 return
1166 try:
1164 try:
1167 # may set last_syntax_error again if a SyntaxError is raised
1165 # may set last_syntax_error again if a SyntaxError is raised
1168 self.safe_execfile(err.filename,self.shell.user_ns)
1166 self.safe_execfile(err.filename,self.shell.user_ns)
1169 except:
1167 except:
1170 self.showtraceback()
1168 self.showtraceback()
1171 else:
1169 else:
1172 f = file(err.filename)
1170 f = file(err.filename)
1173 try:
1171 try:
1174 sys.displayhook(f.read())
1172 sys.displayhook(f.read())
1175 finally:
1173 finally:
1176 f.close()
1174 f.close()
1177
1175
1178 def showsyntaxerror(self, filename=None):
1176 def showsyntaxerror(self, filename=None):
1179 """Display the syntax error that just occurred.
1177 """Display the syntax error that just occurred.
1180
1178
1181 This doesn't display a stack trace because there isn't one.
1179 This doesn't display a stack trace because there isn't one.
1182
1180
1183 If a filename is given, it is stuffed in the exception instead
1181 If a filename is given, it is stuffed in the exception instead
1184 of what was there before (because Python's parser always uses
1182 of what was there before (because Python's parser always uses
1185 "<string>" when reading from a string).
1183 "<string>" when reading from a string).
1186 """
1184 """
1187 etype, value, last_traceback = sys.exc_info()
1185 etype, value, last_traceback = sys.exc_info()
1188 if filename and etype is SyntaxError:
1186 if filename and etype is SyntaxError:
1189 # Work hard to stuff the correct filename in the exception
1187 # Work hard to stuff the correct filename in the exception
1190 try:
1188 try:
1191 msg, (dummy_filename, lineno, offset, line) = value
1189 msg, (dummy_filename, lineno, offset, line) = value
1192 except:
1190 except:
1193 # Not the format we expect; leave it alone
1191 # Not the format we expect; leave it alone
1194 pass
1192 pass
1195 else:
1193 else:
1196 # Stuff in the right filename
1194 # Stuff in the right filename
1197 try:
1195 try:
1198 # Assume SyntaxError is a class exception
1196 # Assume SyntaxError is a class exception
1199 value = SyntaxError(msg, (filename, lineno, offset, line))
1197 value = SyntaxError(msg, (filename, lineno, offset, line))
1200 except:
1198 except:
1201 # If that failed, assume SyntaxError is a string
1199 # If that failed, assume SyntaxError is a string
1202 value = msg, (filename, lineno, offset, line)
1200 value = msg, (filename, lineno, offset, line)
1203 self.SyntaxTB(etype,value,[])
1201 self.SyntaxTB(etype,value,[])
1204
1202
1205 def debugger(self):
1203 def debugger(self):
1206 """Call the pdb debugger."""
1204 """Call the pdb debugger."""
1207
1205
1208 if not self.rc.pdb:
1206 if not self.rc.pdb:
1209 return
1207 return
1210 pdb.pm()
1208 pdb.pm()
1211
1209
1212 def showtraceback(self,exc_tuple = None,filename=None):
1210 def showtraceback(self,exc_tuple = None,filename=None):
1213 """Display the exception that just occurred."""
1211 """Display the exception that just occurred."""
1214
1212
1215 # Though this won't be called by syntax errors in the input line,
1213 # Though this won't be called by syntax errors in the input line,
1216 # there may be SyntaxError cases whith imported code.
1214 # there may be SyntaxError cases whith imported code.
1217 if exc_tuple is None:
1215 if exc_tuple is None:
1218 type, value, tb = sys.exc_info()
1216 type, value, tb = sys.exc_info()
1219 else:
1217 else:
1220 type, value, tb = exc_tuple
1218 type, value, tb = exc_tuple
1221 if type is SyntaxError:
1219 if type is SyntaxError:
1222 self.showsyntaxerror(filename)
1220 self.showsyntaxerror(filename)
1223 else:
1221 else:
1224 self.InteractiveTB()
1222 self.InteractiveTB()
1225 if self.InteractiveTB.call_pdb and self.has_readline:
1223 if self.InteractiveTB.call_pdb and self.has_readline:
1226 # pdb mucks up readline, fix it back
1224 # pdb mucks up readline, fix it back
1227 self.readline.set_completer(self.Completer.complete)
1225 self.readline.set_completer(self.Completer.complete)
1228
1226
1229 def mainloop(self,banner=None):
1227 def mainloop(self,banner=None):
1230 """Creates the local namespace and starts the mainloop.
1228 """Creates the local namespace and starts the mainloop.
1231
1229
1232 If an optional banner argument is given, it will override the
1230 If an optional banner argument is given, it will override the
1233 internally created default banner."""
1231 internally created default banner."""
1234
1232
1235 if self.rc.c: # Emulate Python's -c option
1233 if self.rc.c: # Emulate Python's -c option
1236 self.exec_init_cmd()
1234 self.exec_init_cmd()
1237 if banner is None:
1235 if banner is None:
1238 if self.rc.banner:
1236 if self.rc.banner:
1239 banner = self.BANNER+self.banner2
1237 banner = self.BANNER+self.banner2
1240 else:
1238 else:
1241 banner = ''
1239 banner = ''
1242 self.interact(banner)
1240 self.interact(banner)
1243
1241
1244 def exec_init_cmd(self):
1242 def exec_init_cmd(self):
1245 """Execute a command given at the command line.
1243 """Execute a command given at the command line.
1246
1244
1247 This emulates Python's -c option."""
1245 This emulates Python's -c option."""
1248
1246
1249 sys.argv = ['-c']
1247 sys.argv = ['-c']
1250 self.push(self.rc.c)
1248 self.push(self.rc.c)
1251
1249
1252 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1250 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1253 """Embeds IPython into a running python program.
1251 """Embeds IPython into a running python program.
1254
1252
1255 Input:
1253 Input:
1256
1254
1257 - header: An optional header message can be specified.
1255 - header: An optional header message can be specified.
1258
1256
1259 - local_ns, global_ns: working namespaces. If given as None, the
1257 - local_ns, global_ns: working namespaces. If given as None, the
1260 IPython-initialized one is updated with __main__.__dict__, so that
1258 IPython-initialized one is updated with __main__.__dict__, so that
1261 program variables become visible but user-specific configuration
1259 program variables become visible but user-specific configuration
1262 remains possible.
1260 remains possible.
1263
1261
1264 - stack_depth: specifies how many levels in the stack to go to
1262 - stack_depth: specifies how many levels in the stack to go to
1265 looking for namespaces (when local_ns and global_ns are None). This
1263 looking for namespaces (when local_ns and global_ns are None). This
1266 allows an intermediate caller to make sure that this function gets
1264 allows an intermediate caller to make sure that this function gets
1267 the namespace from the intended level in the stack. By default (0)
1265 the namespace from the intended level in the stack. By default (0)
1268 it will get its locals and globals from the immediate caller.
1266 it will get its locals and globals from the immediate caller.
1269
1267
1270 Warning: it's possible to use this in a program which is being run by
1268 Warning: it's possible to use this in a program which is being run by
1271 IPython itself (via %run), but some funny things will happen (a few
1269 IPython itself (via %run), but some funny things will happen (a few
1272 globals get overwritten). In the future this will be cleaned up, as
1270 globals get overwritten). In the future this will be cleaned up, as
1273 there is no fundamental reason why it can't work perfectly."""
1271 there is no fundamental reason why it can't work perfectly."""
1274
1272
1275 # Get locals and globals from caller
1273 # Get locals and globals from caller
1276 if local_ns is None or global_ns is None:
1274 if local_ns is None or global_ns is None:
1277 call_frame = sys._getframe(stack_depth).f_back
1275 call_frame = sys._getframe(stack_depth).f_back
1278
1276
1279 if local_ns is None:
1277 if local_ns is None:
1280 local_ns = call_frame.f_locals
1278 local_ns = call_frame.f_locals
1281 if global_ns is None:
1279 if global_ns is None:
1282 global_ns = call_frame.f_globals
1280 global_ns = call_frame.f_globals
1283
1281
1284 # Update namespaces and fire up interpreter
1282 # Update namespaces and fire up interpreter
1285 self.user_ns = local_ns
1283 self.user_ns = local_ns
1286 self.user_global_ns = global_ns
1284 self.user_global_ns = global_ns
1287
1285
1288 # Patch for global embedding to make sure that things don't overwrite
1286 # Patch for global embedding to make sure that things don't overwrite
1289 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1287 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1290 # FIXME. Test this a bit more carefully (the if.. is new)
1288 # FIXME. Test this a bit more carefully (the if.. is new)
1291 if local_ns is None and global_ns is None:
1289 if local_ns is None and global_ns is None:
1292 self.user_global_ns.update(__main__.__dict__)
1290 self.user_global_ns.update(__main__.__dict__)
1293
1291
1294 # make sure the tab-completer has the correct frame information, so it
1292 # make sure the tab-completer has the correct frame information, so it
1295 # actually completes using the frame's locals/globals
1293 # actually completes using the frame's locals/globals
1296 self.set_completer_frame(call_frame)
1294 self.set_completer_frame(call_frame)
1297
1295
1298 self.interact(header)
1296 self.interact(header)
1299
1297
1300 def interact(self, banner=None):
1298 def interact(self, banner=None):
1301 """Closely emulate the interactive Python console.
1299 """Closely emulate the interactive Python console.
1302
1300
1303 The optional banner argument specify the banner to print
1301 The optional banner argument specify the banner to print
1304 before the first interaction; by default it prints a banner
1302 before the first interaction; by default it prints a banner
1305 similar to the one printed by the real Python interpreter,
1303 similar to the one printed by the real Python interpreter,
1306 followed by the current class name in parentheses (so as not
1304 followed by the current class name in parentheses (so as not
1307 to confuse this with the real interpreter -- since it's so
1305 to confuse this with the real interpreter -- since it's so
1308 close!).
1306 close!).
1309
1307
1310 """
1308 """
1311 cprt = 'Type "copyright", "credits" or "license" for more information.'
1309 cprt = 'Type "copyright", "credits" or "license" for more information.'
1312 if banner is None:
1310 if banner is None:
1313 self.write("Python %s on %s\n%s\n(%s)\n" %
1311 self.write("Python %s on %s\n%s\n(%s)\n" %
1314 (sys.version, sys.platform, cprt,
1312 (sys.version, sys.platform, cprt,
1315 self.__class__.__name__))
1313 self.__class__.__name__))
1316 else:
1314 else:
1317 self.write(banner)
1315 self.write(banner)
1318
1316
1319 more = 0
1317 more = 0
1320
1318
1321 # Mark activity in the builtins
1319 # Mark activity in the builtins
1322 __builtin__.__dict__['__IPYTHON__active'] += 1
1320 __builtin__.__dict__['__IPYTHON__active'] += 1
1323
1321
1324 # exit_now is set by a call to %Exit or %Quit
1322 # exit_now is set by a call to %Exit or %Quit
1325 while not self.exit_now:
1323 while not self.exit_now:
1326 try:
1324 try:
1327 if more:
1325 if more:
1328 prompt = self.outputcache.prompt2
1326 prompt = self.outputcache.prompt2
1329 if self.autoindent:
1327 if self.autoindent:
1330 self.readline_startup_hook(self.pre_readline)
1328 self.readline_startup_hook(self.pre_readline)
1331 else:
1329 else:
1332 prompt = self.outputcache.prompt1
1330 prompt = self.outputcache.prompt1
1333 try:
1331 try:
1334 line = self.raw_input(prompt,more)
1332 line = self.raw_input(prompt,more)
1335 if self.autoindent:
1333 if self.autoindent:
1336 self.readline_startup_hook(None)
1334 self.readline_startup_hook(None)
1337 except EOFError:
1335 except EOFError:
1338 if self.autoindent:
1336 if self.autoindent:
1339 self.readline_startup_hook(None)
1337 self.readline_startup_hook(None)
1340 self.write("\n")
1338 self.write("\n")
1341 self.exit()
1339 self.exit()
1342 else:
1340 else:
1343 more = self.push(line)
1341 more = self.push(line)
1344
1342
1345 if (self.SyntaxTB.last_syntax_error and
1343 if (self.SyntaxTB.last_syntax_error and
1346 self.rc.autoedit_syntax):
1344 self.rc.autoedit_syntax):
1347 self.edit_syntax_error()
1345 self.edit_syntax_error()
1348
1346
1349 except KeyboardInterrupt:
1347 except KeyboardInterrupt:
1350 self.write("\nKeyboardInterrupt\n")
1348 self.write("\nKeyboardInterrupt\n")
1351 self.resetbuffer()
1349 self.resetbuffer()
1352 more = 0
1350 more = 0
1353 # keep cache in sync with the prompt counter:
1351 # keep cache in sync with the prompt counter:
1354 self.outputcache.prompt_count -= 1
1352 self.outputcache.prompt_count -= 1
1355
1353
1356 if self.autoindent:
1354 if self.autoindent:
1357 self.indent_current_nsp = 0
1355 self.indent_current_nsp = 0
1358 self.indent_current = ' '* self.indent_current_nsp
1356 self.indent_current = ' '* self.indent_current_nsp
1359
1357
1360 except bdb.BdbQuit:
1358 except bdb.BdbQuit:
1361 warn("The Python debugger has exited with a BdbQuit exception.\n"
1359 warn("The Python debugger has exited with a BdbQuit exception.\n"
1362 "Because of how pdb handles the stack, it is impossible\n"
1360 "Because of how pdb handles the stack, it is impossible\n"
1363 "for IPython to properly format this particular exception.\n"
1361 "for IPython to properly format this particular exception.\n"
1364 "IPython will resume normal operation.")
1362 "IPython will resume normal operation.")
1365
1363
1366 # We are off again...
1364 # We are off again...
1367 __builtin__.__dict__['__IPYTHON__active'] -= 1
1365 __builtin__.__dict__['__IPYTHON__active'] -= 1
1368
1366
1369 def excepthook(self, type, value, tb):
1367 def excepthook(self, type, value, tb):
1370 """One more defense for GUI apps that call sys.excepthook.
1368 """One more defense for GUI apps that call sys.excepthook.
1371
1369
1372 GUI frameworks like wxPython trap exceptions and call
1370 GUI frameworks like wxPython trap exceptions and call
1373 sys.excepthook themselves. I guess this is a feature that
1371 sys.excepthook themselves. I guess this is a feature that
1374 enables them to keep running after exceptions that would
1372 enables them to keep running after exceptions that would
1375 otherwise kill their mainloop. This is a bother for IPython
1373 otherwise kill their mainloop. This is a bother for IPython
1376 which excepts to catch all of the program exceptions with a try:
1374 which excepts to catch all of the program exceptions with a try:
1377 except: statement.
1375 except: statement.
1378
1376
1379 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1377 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1380 any app directly invokes sys.excepthook, it will look to the user like
1378 any app directly invokes sys.excepthook, it will look to the user like
1381 IPython crashed. In order to work around this, we can disable the
1379 IPython crashed. In order to work around this, we can disable the
1382 CrashHandler and replace it with this excepthook instead, which prints a
1380 CrashHandler and replace it with this excepthook instead, which prints a
1383 regular traceback using our InteractiveTB. In this fashion, apps which
1381 regular traceback using our InteractiveTB. In this fashion, apps which
1384 call sys.excepthook will generate a regular-looking exception from
1382 call sys.excepthook will generate a regular-looking exception from
1385 IPython, and the CrashHandler will only be triggered by real IPython
1383 IPython, and the CrashHandler will only be triggered by real IPython
1386 crashes.
1384 crashes.
1387
1385
1388 This hook should be used sparingly, only in places which are not likely
1386 This hook should be used sparingly, only in places which are not likely
1389 to be true IPython errors.
1387 to be true IPython errors.
1390 """
1388 """
1391
1389
1392 self.InteractiveTB(type, value, tb, tb_offset=0)
1390 self.InteractiveTB(type, value, tb, tb_offset=0)
1393 if self.InteractiveTB.call_pdb and self.has_readline:
1391 if self.InteractiveTB.call_pdb and self.has_readline:
1394 self.readline.set_completer(self.Completer.complete)
1392 self.readline.set_completer(self.Completer.complete)
1395
1393
1396 def call_alias(self,alias,rest=''):
1394 def call_alias(self,alias,rest=''):
1397 """Call an alias given its name and the rest of the line.
1395 """Call an alias given its name and the rest of the line.
1398
1396
1399 This function MUST be given a proper alias, because it doesn't make
1397 This function MUST be given a proper alias, because it doesn't make
1400 any checks when looking up into the alias table. The caller is
1398 any checks when looking up into the alias table. The caller is
1401 responsible for invoking it only with a valid alias."""
1399 responsible for invoking it only with a valid alias."""
1402
1400
1403 #print 'ALIAS: <%s>+<%s>' % (alias,rest) # dbg
1401 #print 'ALIAS: <%s>+<%s>' % (alias,rest) # dbg
1404 nargs,cmd = self.alias_table[alias]
1402 nargs,cmd = self.alias_table[alias]
1405 # Expand the %l special to be the user's input line
1403 # Expand the %l special to be the user's input line
1406 if cmd.find('%l') >= 0:
1404 if cmd.find('%l') >= 0:
1407 cmd = cmd.replace('%l',rest)
1405 cmd = cmd.replace('%l',rest)
1408 rest = ''
1406 rest = ''
1409 if nargs==0:
1407 if nargs==0:
1410 # Simple, argument-less aliases
1408 # Simple, argument-less aliases
1411 cmd = '%s %s' % (cmd,rest)
1409 cmd = '%s %s' % (cmd,rest)
1412 else:
1410 else:
1413 # Handle aliases with positional arguments
1411 # Handle aliases with positional arguments
1414 args = rest.split(None,nargs)
1412 args = rest.split(None,nargs)
1415 if len(args)< nargs:
1413 if len(args)< nargs:
1416 error('Alias <%s> requires %s arguments, %s given.' %
1414 error('Alias <%s> requires %s arguments, %s given.' %
1417 (alias,nargs,len(args)))
1415 (alias,nargs,len(args)))
1418 return
1416 return
1419 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1417 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1420 # Now call the macro, evaluating in the user's namespace
1418 # Now call the macro, evaluating in the user's namespace
1421 try:
1419 try:
1422 self.system(cmd)
1420 self.system(cmd)
1423 except:
1421 except:
1424 self.showtraceback()
1422 self.showtraceback()
1425
1423
1426 def autoindent_update(self,line):
1424 def autoindent_update(self,line):
1427 """Keep track of the indent level."""
1425 """Keep track of the indent level."""
1428 if self.autoindent:
1426 if self.autoindent:
1429 if line:
1427 if line:
1430 ini_spaces = ini_spaces_re.match(line)
1428 ini_spaces = ini_spaces_re.match(line)
1431 if ini_spaces:
1429 if ini_spaces:
1432 nspaces = ini_spaces.end()
1430 nspaces = ini_spaces.end()
1433 else:
1431 else:
1434 nspaces = 0
1432 nspaces = 0
1435 self.indent_current_nsp = nspaces
1433 self.indent_current_nsp = nspaces
1436
1434
1437 if line[-1] == ':':
1435 if line[-1] == ':':
1438 self.indent_current_nsp += 4
1436 self.indent_current_nsp += 4
1439 elif dedent_re.match(line):
1437 elif dedent_re.match(line):
1440 self.indent_current_nsp -= 4
1438 self.indent_current_nsp -= 4
1441 else:
1439 else:
1442 self.indent_current_nsp = 0
1440 self.indent_current_nsp = 0
1443
1441
1444 # indent_current is the actual string to be inserted
1442 # indent_current is the actual string to be inserted
1445 # by the readline hooks for indentation
1443 # by the readline hooks for indentation
1446 self.indent_current = ' '* self.indent_current_nsp
1444 self.indent_current = ' '* self.indent_current_nsp
1447
1445
1448 def runlines(self,lines):
1446 def runlines(self,lines):
1449 """Run a string of one or more lines of source.
1447 """Run a string of one or more lines of source.
1450
1448
1451 This method is capable of running a string containing multiple source
1449 This method is capable of running a string containing multiple source
1452 lines, as if they had been entered at the IPython prompt. Since it
1450 lines, as if they had been entered at the IPython prompt. Since it
1453 exposes IPython's processing machinery, the given strings can contain
1451 exposes IPython's processing machinery, the given strings can contain
1454 magic calls (%magic), special shell access (!cmd), etc."""
1452 magic calls (%magic), special shell access (!cmd), etc."""
1455
1453
1456 # We must start with a clean buffer, in case this is run from an
1454 # We must start with a clean buffer, in case this is run from an
1457 # interactive IPython session (via a magic, for example).
1455 # interactive IPython session (via a magic, for example).
1458 self.resetbuffer()
1456 self.resetbuffer()
1459 lines = lines.split('\n')
1457 lines = lines.split('\n')
1460 more = 0
1458 more = 0
1461 for line in lines:
1459 for line in lines:
1462 # skip blank lines so we don't mess up the prompt counter, but do
1460 # skip blank lines so we don't mess up the prompt counter, but do
1463 # NOT skip even a blank line if we are in a code block (more is
1461 # NOT skip even a blank line if we are in a code block (more is
1464 # true)
1462 # true)
1465 if line or more:
1463 if line or more:
1466 more = self.push(self.prefilter(line,more))
1464 more = self.push(self.prefilter(line,more))
1467 # IPython's runsource returns None if there was an error
1465 # IPython's runsource returns None if there was an error
1468 # compiling the code. This allows us to stop processing right
1466 # compiling the code. This allows us to stop processing right
1469 # away, so the user gets the error message at the right place.
1467 # away, so the user gets the error message at the right place.
1470 if more is None:
1468 if more is None:
1471 break
1469 break
1472 # final newline in case the input didn't have it, so that the code
1470 # final newline in case the input didn't have it, so that the code
1473 # actually does get executed
1471 # actually does get executed
1474 if more:
1472 if more:
1475 self.push('\n')
1473 self.push('\n')
1476
1474
1477 def runsource(self, source, filename='<input>', symbol='single'):
1475 def runsource(self, source, filename='<input>', symbol='single'):
1478 """Compile and run some source in the interpreter.
1476 """Compile and run some source in the interpreter.
1479
1477
1480 Arguments are as for compile_command().
1478 Arguments are as for compile_command().
1481
1479
1482 One several things can happen:
1480 One several things can happen:
1483
1481
1484 1) The input is incorrect; compile_command() raised an
1482 1) The input is incorrect; compile_command() raised an
1485 exception (SyntaxError or OverflowError). A syntax traceback
1483 exception (SyntaxError or OverflowError). A syntax traceback
1486 will be printed by calling the showsyntaxerror() method.
1484 will be printed by calling the showsyntaxerror() method.
1487
1485
1488 2) The input is incomplete, and more input is required;
1486 2) The input is incomplete, and more input is required;
1489 compile_command() returned None. Nothing happens.
1487 compile_command() returned None. Nothing happens.
1490
1488
1491 3) The input is complete; compile_command() returned a code
1489 3) The input is complete; compile_command() returned a code
1492 object. The code is executed by calling self.runcode() (which
1490 object. The code is executed by calling self.runcode() (which
1493 also handles run-time exceptions, except for SystemExit).
1491 also handles run-time exceptions, except for SystemExit).
1494
1492
1495 The return value is:
1493 The return value is:
1496
1494
1497 - True in case 2
1495 - True in case 2
1498
1496
1499 - False in the other cases, unless an exception is raised, where
1497 - False in the other cases, unless an exception is raised, where
1500 None is returned instead. This can be used by external callers to
1498 None is returned instead. This can be used by external callers to
1501 know whether to continue feeding input or not.
1499 know whether to continue feeding input or not.
1502
1500
1503 The return value can be used to decide whether to use sys.ps1 or
1501 The return value can be used to decide whether to use sys.ps1 or
1504 sys.ps2 to prompt the next line."""
1502 sys.ps2 to prompt the next line."""
1505
1503
1506 try:
1504 try:
1507 code = self.compile(source,filename,symbol)
1505 code = self.compile(source,filename,symbol)
1508 except (OverflowError, SyntaxError, ValueError):
1506 except (OverflowError, SyntaxError, ValueError):
1509 # Case 1
1507 # Case 1
1510 self.showsyntaxerror(filename)
1508 self.showsyntaxerror(filename)
1511 return None
1509 return None
1512
1510
1513 if code is None:
1511 if code is None:
1514 # Case 2
1512 # Case 2
1515 return True
1513 return True
1516
1514
1517 # Case 3
1515 # Case 3
1518 # We store the code object so that threaded shells and
1516 # We store the code object so that threaded shells and
1519 # custom exception handlers can access all this info if needed.
1517 # custom exception handlers can access all this info if needed.
1520 # The source corresponding to this can be obtained from the
1518 # The source corresponding to this can be obtained from the
1521 # buffer attribute as '\n'.join(self.buffer).
1519 # buffer attribute as '\n'.join(self.buffer).
1522 self.code_to_run = code
1520 self.code_to_run = code
1523 # now actually execute the code object
1521 # now actually execute the code object
1524 if self.runcode(code) == 0:
1522 if self.runcode(code) == 0:
1525 return False
1523 return False
1526 else:
1524 else:
1527 return None
1525 return None
1528
1526
1529 def runcode(self,code_obj):
1527 def runcode(self,code_obj):
1530 """Execute a code object.
1528 """Execute a code object.
1531
1529
1532 When an exception occurs, self.showtraceback() is called to display a
1530 When an exception occurs, self.showtraceback() is called to display a
1533 traceback.
1531 traceback.
1534
1532
1535 Return value: a flag indicating whether the code to be run completed
1533 Return value: a flag indicating whether the code to be run completed
1536 successfully:
1534 successfully:
1537
1535
1538 - 0: successful execution.
1536 - 0: successful execution.
1539 - 1: an error occurred.
1537 - 1: an error occurred.
1540 """
1538 """
1541
1539
1542 # Set our own excepthook in case the user code tries to call it
1540 # Set our own excepthook in case the user code tries to call it
1543 # directly, so that the IPython crash handler doesn't get triggered
1541 # directly, so that the IPython crash handler doesn't get triggered
1544 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1542 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1545
1543
1546 # we save the original sys.excepthook in the instance, in case config
1544 # we save the original sys.excepthook in the instance, in case config
1547 # code (such as magics) needs access to it.
1545 # code (such as magics) needs access to it.
1548 self.sys_excepthook = old_excepthook
1546 self.sys_excepthook = old_excepthook
1549 outflag = 1 # happens in more places, so it's easier as default
1547 outflag = 1 # happens in more places, so it's easier as default
1550 try:
1548 try:
1551 try:
1549 try:
1552 # Embedded instances require separate global/local namespaces
1550 # Embedded instances require separate global/local namespaces
1553 # so they can see both the surrounding (local) namespace and
1551 # so they can see both the surrounding (local) namespace and
1554 # the module-level globals when called inside another function.
1552 # the module-level globals when called inside another function.
1555 if self.embedded:
1553 if self.embedded:
1556 exec code_obj in self.user_global_ns, self.user_ns
1554 exec code_obj in self.user_global_ns, self.user_ns
1557 # Normal (non-embedded) instances should only have a single
1555 # Normal (non-embedded) instances should only have a single
1558 # namespace for user code execution, otherwise functions won't
1556 # namespace for user code execution, otherwise functions won't
1559 # see interactive top-level globals.
1557 # see interactive top-level globals.
1560 else:
1558 else:
1561 exec code_obj in self.user_ns
1559 exec code_obj in self.user_ns
1562 finally:
1560 finally:
1563 # Reset our crash handler in place
1561 # Reset our crash handler in place
1564 sys.excepthook = old_excepthook
1562 sys.excepthook = old_excepthook
1565 except SystemExit:
1563 except SystemExit:
1566 self.resetbuffer()
1564 self.resetbuffer()
1567 self.showtraceback()
1565 self.showtraceback()
1568 warn("Type exit or quit to exit IPython "
1566 warn("Type exit or quit to exit IPython "
1569 "(%Exit or %Quit do so unconditionally).",level=1)
1567 "(%Exit or %Quit do so unconditionally).",level=1)
1570 except self.custom_exceptions:
1568 except self.custom_exceptions:
1571 etype,value,tb = sys.exc_info()
1569 etype,value,tb = sys.exc_info()
1572 self.CustomTB(etype,value,tb)
1570 self.CustomTB(etype,value,tb)
1573 except:
1571 except:
1574 self.showtraceback()
1572 self.showtraceback()
1575 else:
1573 else:
1576 outflag = 0
1574 outflag = 0
1577 if softspace(sys.stdout, 0):
1575 if softspace(sys.stdout, 0):
1578 print
1576 print
1579 # Flush out code object which has been run (and source)
1577 # Flush out code object which has been run (and source)
1580 self.code_to_run = None
1578 self.code_to_run = None
1581 return outflag
1579 return outflag
1582
1580
1583 def push(self, line):
1581 def push(self, line):
1584 """Push a line to the interpreter.
1582 """Push a line to the interpreter.
1585
1583
1586 The line should not have a trailing newline; it may have
1584 The line should not have a trailing newline; it may have
1587 internal newlines. The line is appended to a buffer and the
1585 internal newlines. The line is appended to a buffer and the
1588 interpreter's runsource() method is called with the
1586 interpreter's runsource() method is called with the
1589 concatenated contents of the buffer as source. If this
1587 concatenated contents of the buffer as source. If this
1590 indicates that the command was executed or invalid, the buffer
1588 indicates that the command was executed or invalid, the buffer
1591 is reset; otherwise, the command is incomplete, and the buffer
1589 is reset; otherwise, the command is incomplete, and the buffer
1592 is left as it was after the line was appended. The return
1590 is left as it was after the line was appended. The return
1593 value is 1 if more input is required, 0 if the line was dealt
1591 value is 1 if more input is required, 0 if the line was dealt
1594 with in some way (this is the same as runsource()).
1592 with in some way (this is the same as runsource()).
1595 """
1593 """
1596
1594
1597 # autoindent management should be done here, and not in the
1595 # autoindent management should be done here, and not in the
1598 # interactive loop, since that one is only seen by keyboard input. We
1596 # interactive loop, since that one is only seen by keyboard input. We
1599 # need this done correctly even for code run via runlines (which uses
1597 # need this done correctly even for code run via runlines (which uses
1600 # push).
1598 # push).
1601
1599
1602 #print 'push line: <%s>' % line # dbg
1600 #print 'push line: <%s>' % line # dbg
1603 self.autoindent_update(line)
1601 self.autoindent_update(line)
1604
1602
1605 self.buffer.append(line)
1603 self.buffer.append(line)
1606 more = self.runsource('\n'.join(self.buffer), self.filename)
1604 more = self.runsource('\n'.join(self.buffer), self.filename)
1607 if not more:
1605 if not more:
1608 self.resetbuffer()
1606 self.resetbuffer()
1609 return more
1607 return more
1610
1608
1611 def resetbuffer(self):
1609 def resetbuffer(self):
1612 """Reset the input buffer."""
1610 """Reset the input buffer."""
1613 self.buffer[:] = []
1611 self.buffer[:] = []
1614
1612
1615 def raw_input(self,prompt='',continue_prompt=False):
1613 def raw_input(self,prompt='',continue_prompt=False):
1616 """Write a prompt and read a line.
1614 """Write a prompt and read a line.
1617
1615
1618 The returned line does not include the trailing newline.
1616 The returned line does not include the trailing newline.
1619 When the user enters the EOF key sequence, EOFError is raised.
1617 When the user enters the EOF key sequence, EOFError is raised.
1620
1618
1621 Optional inputs:
1619 Optional inputs:
1622
1620
1623 - prompt(''): a string to be printed to prompt the user.
1621 - prompt(''): a string to be printed to prompt the user.
1624
1622
1625 - continue_prompt(False): whether this line is the first one or a
1623 - continue_prompt(False): whether this line is the first one or a
1626 continuation in a sequence of inputs.
1624 continuation in a sequence of inputs.
1627 """
1625 """
1628
1626
1629 line = raw_input_original(prompt)
1627 line = raw_input_original(prompt)
1630 # Try to be reasonably smart about not re-indenting pasted input more
1628 # Try to be reasonably smart about not re-indenting pasted input more
1631 # than necessary. We do this by trimming out the auto-indent initial
1629 # than necessary. We do this by trimming out the auto-indent initial
1632 # spaces, if the user's actual input started itself with whitespace.
1630 # spaces, if the user's actual input started itself with whitespace.
1633 if self.autoindent:
1631 if self.autoindent:
1634 line2 = line[self.indent_current_nsp:]
1632 line2 = line[self.indent_current_nsp:]
1635 if line2[0:1] in (' ','\t'):
1633 if line2[0:1] in (' ','\t'):
1636 line = line2
1634 line = line2
1637 return self.prefilter(line,continue_prompt)
1635 return self.prefilter(line,continue_prompt)
1638
1636
1639 def split_user_input(self,line):
1637 def split_user_input(self,line):
1640 """Split user input into pre-char, function part and rest."""
1638 """Split user input into pre-char, function part and rest."""
1641
1639
1642 lsplit = self.line_split.match(line)
1640 lsplit = self.line_split.match(line)
1643 if lsplit is None: # no regexp match returns None
1641 if lsplit is None: # no regexp match returns None
1644 try:
1642 try:
1645 iFun,theRest = line.split(None,1)
1643 iFun,theRest = line.split(None,1)
1646 except ValueError:
1644 except ValueError:
1647 iFun,theRest = line,''
1645 iFun,theRest = line,''
1648 pre = re.match('^(\s*)(.*)',line).groups()[0]
1646 pre = re.match('^(\s*)(.*)',line).groups()[0]
1649 else:
1647 else:
1650 pre,iFun,theRest = lsplit.groups()
1648 pre,iFun,theRest = lsplit.groups()
1651
1649
1652 #print 'line:<%s>' % line # dbg
1650 #print 'line:<%s>' % line # dbg
1653 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
1651 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
1654 return pre,iFun.strip(),theRest
1652 return pre,iFun.strip(),theRest
1655
1653
1656 def _prefilter(self, line, continue_prompt):
1654 def _prefilter(self, line, continue_prompt):
1657 """Calls different preprocessors, depending on the form of line."""
1655 """Calls different preprocessors, depending on the form of line."""
1658
1656
1659 # All handlers *must* return a value, even if it's blank ('').
1657 # All handlers *must* return a value, even if it's blank ('').
1660
1658
1661 # Lines are NOT logged here. Handlers should process the line as
1659 # Lines are NOT logged here. Handlers should process the line as
1662 # needed, update the cache AND log it (so that the input cache array
1660 # needed, update the cache AND log it (so that the input cache array
1663 # stays synced).
1661 # stays synced).
1664
1662
1665 # This function is _very_ delicate, and since it's also the one which
1663 # This function is _very_ delicate, and since it's also the one which
1666 # determines IPython's response to user input, it must be as efficient
1664 # determines IPython's response to user input, it must be as efficient
1667 # as possible. For this reason it has _many_ returns in it, trying
1665 # as possible. For this reason it has _many_ returns in it, trying
1668 # always to exit as quickly as it can figure out what it needs to do.
1666 # always to exit as quickly as it can figure out what it needs to do.
1669
1667
1670 # This function is the main responsible for maintaining IPython's
1668 # This function is the main responsible for maintaining IPython's
1671 # behavior respectful of Python's semantics. So be _very_ careful if
1669 # behavior respectful of Python's semantics. So be _very_ careful if
1672 # making changes to anything here.
1670 # making changes to anything here.
1673
1671
1674 #.....................................................................
1672 #.....................................................................
1675 # Code begins
1673 # Code begins
1676
1674
1677 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
1675 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
1678
1676
1679 # save the line away in case we crash, so the post-mortem handler can
1677 # save the line away in case we crash, so the post-mortem handler can
1680 # record it
1678 # record it
1681 self._last_input_line = line
1679 self._last_input_line = line
1682
1680
1683 #print '***line: <%s>' % line # dbg
1681 #print '***line: <%s>' % line # dbg
1684
1682
1685 # the input history needs to track even empty lines
1683 # the input history needs to track even empty lines
1686 if not line.strip():
1684 if not line.strip():
1687 if not continue_prompt:
1685 if not continue_prompt:
1688 self.outputcache.prompt_count -= 1
1686 self.outputcache.prompt_count -= 1
1689 return self.handle_normal(line,continue_prompt)
1687 return self.handle_normal(line,continue_prompt)
1690 #return self.handle_normal('',continue_prompt)
1688 #return self.handle_normal('',continue_prompt)
1691
1689
1692 # print '***cont',continue_prompt # dbg
1690 # print '***cont',continue_prompt # dbg
1693 # special handlers are only allowed for single line statements
1691 # special handlers are only allowed for single line statements
1694 if continue_prompt and not self.rc.multi_line_specials:
1692 if continue_prompt and not self.rc.multi_line_specials:
1695 return self.handle_normal(line,continue_prompt)
1693 return self.handle_normal(line,continue_prompt)
1696
1694
1697 # For the rest, we need the structure of the input
1695 # For the rest, we need the structure of the input
1698 pre,iFun,theRest = self.split_user_input(line)
1696 pre,iFun,theRest = self.split_user_input(line)
1699 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1697 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1700
1698
1701 # First check for explicit escapes in the last/first character
1699 # First check for explicit escapes in the last/first character
1702 handler = None
1700 handler = None
1703 if line[-1] == self.ESC_HELP:
1701 if line[-1] == self.ESC_HELP:
1704 handler = self.esc_handlers.get(line[-1]) # the ? can be at the end
1702 handler = self.esc_handlers.get(line[-1]) # the ? can be at the end
1705 if handler is None:
1703 if handler is None:
1706 # look at the first character of iFun, NOT of line, so we skip
1704 # look at the first character of iFun, NOT of line, so we skip
1707 # leading whitespace in multiline input
1705 # leading whitespace in multiline input
1708 handler = self.esc_handlers.get(iFun[0:1])
1706 handler = self.esc_handlers.get(iFun[0:1])
1709 if handler is not None:
1707 if handler is not None:
1710 return handler(line,continue_prompt,pre,iFun,theRest)
1708 return handler(line,continue_prompt,pre,iFun,theRest)
1711 # Emacs ipython-mode tags certain input lines
1709 # Emacs ipython-mode tags certain input lines
1712 if line.endswith('# PYTHON-MODE'):
1710 if line.endswith('# PYTHON-MODE'):
1713 return self.handle_emacs(line,continue_prompt)
1711 return self.handle_emacs(line,continue_prompt)
1714
1712
1715 # Next, check if we can automatically execute this thing
1713 # Next, check if we can automatically execute this thing
1716
1714
1717 # Allow ! in multi-line statements if multi_line_specials is on:
1715 # Allow ! in multi-line statements if multi_line_specials is on:
1718 if continue_prompt and self.rc.multi_line_specials and \
1716 if continue_prompt and self.rc.multi_line_specials and \
1719 iFun.startswith(self.ESC_SHELL):
1717 iFun.startswith(self.ESC_SHELL):
1720 return self.handle_shell_escape(line,continue_prompt,
1718 return self.handle_shell_escape(line,continue_prompt,
1721 pre=pre,iFun=iFun,
1719 pre=pre,iFun=iFun,
1722 theRest=theRest)
1720 theRest=theRest)
1723
1721
1724 # Let's try to find if the input line is a magic fn
1722 # Let's try to find if the input line is a magic fn
1725 oinfo = None
1723 oinfo = None
1726 if hasattr(self,'magic_'+iFun):
1724 if hasattr(self,'magic_'+iFun):
1727 # WARNING: _ofind uses getattr(), so it can consume generators and
1725 # WARNING: _ofind uses getattr(), so it can consume generators and
1728 # cause other side effects.
1726 # cause other side effects.
1729 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1727 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1730 if oinfo['ismagic']:
1728 if oinfo['ismagic']:
1731 # Be careful not to call magics when a variable assignment is
1729 # Be careful not to call magics when a variable assignment is
1732 # being made (ls='hi', for example)
1730 # being made (ls='hi', for example)
1733 if self.rc.automagic and \
1731 if self.rc.automagic and \
1734 (len(theRest)==0 or theRest[0] not in '!=()<>,') and \
1732 (len(theRest)==0 or theRest[0] not in '!=()<>,') and \
1735 (self.rc.multi_line_specials or not continue_prompt):
1733 (self.rc.multi_line_specials or not continue_prompt):
1736 return self.handle_magic(line,continue_prompt,
1734 return self.handle_magic(line,continue_prompt,
1737 pre,iFun,theRest)
1735 pre,iFun,theRest)
1738 else:
1736 else:
1739 return self.handle_normal(line,continue_prompt)
1737 return self.handle_normal(line,continue_prompt)
1740
1738
1741 # If the rest of the line begins with an (in)equality, assginment or
1739 # If the rest of the line begins with an (in)equality, assginment or
1742 # function call, we should not call _ofind but simply execute it.
1740 # function call, we should not call _ofind but simply execute it.
1743 # This avoids spurious geattr() accesses on objects upon assignment.
1741 # This avoids spurious geattr() accesses on objects upon assignment.
1744 #
1742 #
1745 # It also allows users to assign to either alias or magic names true
1743 # It also allows users to assign to either alias or magic names true
1746 # python variables (the magic/alias systems always take second seat to
1744 # python variables (the magic/alias systems always take second seat to
1747 # true python code).
1745 # true python code).
1748 if theRest and theRest[0] in '!=()':
1746 if theRest and theRest[0] in '!=()':
1749 return self.handle_normal(line,continue_prompt)
1747 return self.handle_normal(line,continue_prompt)
1750
1748
1751 if oinfo is None:
1749 if oinfo is None:
1752 # let's try to ensure that _oinfo is ONLY called when autocall is
1750 # let's try to ensure that _oinfo is ONLY called when autocall is
1753 # on. Since it has inevitable potential side effects, at least
1751 # on. Since it has inevitable potential side effects, at least
1754 # having autocall off should be a guarantee to the user that no
1752 # having autocall off should be a guarantee to the user that no
1755 # weird things will happen.
1753 # weird things will happen.
1756
1754
1757 if self.rc.autocall:
1755 if self.rc.autocall:
1758 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1756 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1759 else:
1757 else:
1760 # in this case, all that's left is either an alias or
1758 # in this case, all that's left is either an alias or
1761 # processing the line normally.
1759 # processing the line normally.
1762 if iFun in self.alias_table:
1760 if iFun in self.alias_table:
1763 return self.handle_alias(line,continue_prompt,
1761 return self.handle_alias(line,continue_prompt,
1764 pre,iFun,theRest)
1762 pre,iFun,theRest)
1765 else:
1763 else:
1766 return self.handle_normal(line,continue_prompt)
1764 return self.handle_normal(line,continue_prompt)
1767
1765
1768 if not oinfo['found']:
1766 if not oinfo['found']:
1769 return self.handle_normal(line,continue_prompt)
1767 return self.handle_normal(line,continue_prompt)
1770 else:
1768 else:
1771 #print 'iFun <%s> rest <%s>' % (iFun,theRest) # dbg
1769 #print 'iFun <%s> rest <%s>' % (iFun,theRest) # dbg
1772 if oinfo['isalias']:
1770 if oinfo['isalias']:
1773 return self.handle_alias(line,continue_prompt,
1771 return self.handle_alias(line,continue_prompt,
1774 pre,iFun,theRest)
1772 pre,iFun,theRest)
1775
1773
1776 if self.rc.autocall and \
1774 if self.rc.autocall and \
1777 not self.re_exclude_auto.match(theRest) and \
1775 not self.re_exclude_auto.match(theRest) and \
1778 self.re_fun_name.match(iFun) and \
1776 self.re_fun_name.match(iFun) and \
1779 callable(oinfo['obj']) :
1777 callable(oinfo['obj']) :
1780 #print 'going auto' # dbg
1778 #print 'going auto' # dbg
1781 return self.handle_auto(line,continue_prompt,pre,iFun,theRest)
1779 return self.handle_auto(line,continue_prompt,pre,iFun,theRest)
1782 else:
1780 else:
1783 #print 'was callable?', callable(oinfo['obj']) # dbg
1781 #print 'was callable?', callable(oinfo['obj']) # dbg
1784 return self.handle_normal(line,continue_prompt)
1782 return self.handle_normal(line,continue_prompt)
1785
1783
1786 # If we get here, we have a normal Python line. Log and return.
1784 # If we get here, we have a normal Python line. Log and return.
1787 return self.handle_normal(line,continue_prompt)
1785 return self.handle_normal(line,continue_prompt)
1788
1786
1789 def _prefilter_dumb(self, line, continue_prompt):
1787 def _prefilter_dumb(self, line, continue_prompt):
1790 """simple prefilter function, for debugging"""
1788 """simple prefilter function, for debugging"""
1791 return self.handle_normal(line,continue_prompt)
1789 return self.handle_normal(line,continue_prompt)
1792
1790
1793 # Set the default prefilter() function (this can be user-overridden)
1791 # Set the default prefilter() function (this can be user-overridden)
1794 prefilter = _prefilter
1792 prefilter = _prefilter
1795
1793
1796 def handle_normal(self,line,continue_prompt=None,
1794 def handle_normal(self,line,continue_prompt=None,
1797 pre=None,iFun=None,theRest=None):
1795 pre=None,iFun=None,theRest=None):
1798 """Handle normal input lines. Use as a template for handlers."""
1796 """Handle normal input lines. Use as a template for handlers."""
1799
1797
1800 # With autoindent on, we need some way to exit the input loop, and I
1798 # With autoindent on, we need some way to exit the input loop, and I
1801 # don't want to force the user to have to backspace all the way to
1799 # don't want to force the user to have to backspace all the way to
1802 # clear the line. The rule will be in this case, that either two
1800 # clear the line. The rule will be in this case, that either two
1803 # lines of pure whitespace in a row, or a line of pure whitespace but
1801 # lines of pure whitespace in a row, or a line of pure whitespace but
1804 # of a size different to the indent level, will exit the input loop.
1802 # of a size different to the indent level, will exit the input loop.
1805
1803
1806 if (continue_prompt and self.autoindent and isspace(line) and
1804 if (continue_prompt and self.autoindent and isspace(line) and
1807 (line != self.indent_current or isspace(self.buffer[-1]))):
1805 (line != self.indent_current or isspace(self.buffer[-1]))):
1808 line = ''
1806 line = ''
1809
1807
1810 self.log(line,continue_prompt)
1808 self.log(line,continue_prompt)
1811 return line
1809 return line
1812
1810
1813 def handle_alias(self,line,continue_prompt=None,
1811 def handle_alias(self,line,continue_prompt=None,
1814 pre=None,iFun=None,theRest=None):
1812 pre=None,iFun=None,theRest=None):
1815 """Handle alias input lines. """
1813 """Handle alias input lines. """
1816
1814
1817 # pre is needed, because it carries the leading whitespace. Otherwise
1815 # pre is needed, because it carries the leading whitespace. Otherwise
1818 # aliases won't work in indented sections.
1816 # aliases won't work in indented sections.
1819 line_out = '%sipalias("%s %s")' % (pre,iFun,esc_quotes(theRest))
1817 line_out = '%sipalias("%s %s")' % (pre,iFun,esc_quotes(theRest))
1820 self.log(line_out,continue_prompt)
1818 self.log(line_out,continue_prompt)
1821 return line_out
1819 return line_out
1822
1820
1823 def handle_shell_escape(self, line, continue_prompt=None,
1821 def handle_shell_escape(self, line, continue_prompt=None,
1824 pre=None,iFun=None,theRest=None):
1822 pre=None,iFun=None,theRest=None):
1825 """Execute the line in a shell, empty return value"""
1823 """Execute the line in a shell, empty return value"""
1826
1824
1827 #print 'line in :', `line` # dbg
1825 #print 'line in :', `line` # dbg
1828 # Example of a special handler. Others follow a similar pattern.
1826 # Example of a special handler. Others follow a similar pattern.
1829 if continue_prompt: # multi-line statements
1827 if continue_prompt: # multi-line statements
1830 if iFun.startswith('!!'):
1828 if iFun.startswith('!!'):
1831 print 'SyntaxError: !! is not allowed in multiline statements'
1829 print 'SyntaxError: !! is not allowed in multiline statements'
1832 return pre
1830 return pre
1833 else:
1831 else:
1834 cmd = ("%s %s" % (iFun[1:],theRest))
1832 cmd = ("%s %s" % (iFun[1:],theRest))
1835 line_out = '%sipsystem(r"""%s"""[:-1])' % (pre,cmd + "_")
1833 line_out = '%sipsystem(r"""%s"""[:-1])' % (pre,cmd + "_")
1836 else: # single-line input
1834 else: # single-line input
1837 if line.startswith('!!'):
1835 if line.startswith('!!'):
1838 # rewrite iFun/theRest to properly hold the call to %sx and
1836 # rewrite iFun/theRest to properly hold the call to %sx and
1839 # the actual command to be executed, so handle_magic can work
1837 # the actual command to be executed, so handle_magic can work
1840 # correctly
1838 # correctly
1841 theRest = '%s %s' % (iFun[2:],theRest)
1839 theRest = '%s %s' % (iFun[2:],theRest)
1842 iFun = 'sx'
1840 iFun = 'sx'
1843 return self.handle_magic('%ssx %s' % (self.ESC_MAGIC,line[2:]),
1841 return self.handle_magic('%ssx %s' % (self.ESC_MAGIC,line[2:]),
1844 continue_prompt,pre,iFun,theRest)
1842 continue_prompt,pre,iFun,theRest)
1845 else:
1843 else:
1846 cmd=line[1:]
1844 cmd=line[1:]
1847 line_out = '%sipsystem(r"""%s"""[:-1])' % (pre,cmd +"_")
1845 line_out = '%sipsystem(r"""%s"""[:-1])' % (pre,cmd +"_")
1848 # update cache/log and return
1846 # update cache/log and return
1849 self.log(line_out,continue_prompt)
1847 self.log(line_out,continue_prompt)
1850 return line_out
1848 return line_out
1851
1849
1852 def handle_magic(self, line, continue_prompt=None,
1850 def handle_magic(self, line, continue_prompt=None,
1853 pre=None,iFun=None,theRest=None):
1851 pre=None,iFun=None,theRest=None):
1854 """Execute magic functions.
1852 """Execute magic functions.
1855
1853
1856 Also log them with a prepended # so the log is clean Python."""
1854 Also log them with a prepended # so the log is clean Python."""
1857
1855
1858 cmd = '%sipmagic("%s")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))
1856 cmd = '%sipmagic("%s")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))
1859 self.log(cmd,continue_prompt)
1857 self.log(cmd,continue_prompt)
1860 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
1858 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
1861 return cmd
1859 return cmd
1862
1860
1863 def handle_auto(self, line, continue_prompt=None,
1861 def handle_auto(self, line, continue_prompt=None,
1864 pre=None,iFun=None,theRest=None):
1862 pre=None,iFun=None,theRest=None):
1865 """Hande lines which can be auto-executed, quoting if requested."""
1863 """Hande lines which can be auto-executed, quoting if requested."""
1866
1864
1867 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1865 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1868
1866
1869 # This should only be active for single-line input!
1867 # This should only be active for single-line input!
1870 if continue_prompt:
1868 if continue_prompt:
1871 return line
1869 return line
1872
1870
1873 if pre == self.ESC_QUOTE:
1871 if pre == self.ESC_QUOTE:
1874 # Auto-quote splitting on whitespace
1872 # Auto-quote splitting on whitespace
1875 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
1873 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
1876 elif pre == self.ESC_QUOTE2:
1874 elif pre == self.ESC_QUOTE2:
1877 # Auto-quote whole string
1875 # Auto-quote whole string
1878 newcmd = '%s("%s")' % (iFun,theRest)
1876 newcmd = '%s("%s")' % (iFun,theRest)
1879 else:
1877 else:
1880 # Auto-paren
1878 # Auto-paren
1881 if theRest[0:1] in ('=','['):
1879 if theRest[0:1] in ('=','['):
1882 # Don't autocall in these cases. They can be either
1880 # Don't autocall in these cases. They can be either
1883 # rebindings of an existing callable's name, or item access
1881 # rebindings of an existing callable's name, or item access
1884 # for an object which is BOTH callable and implements
1882 # for an object which is BOTH callable and implements
1885 # __getitem__.
1883 # __getitem__.
1886 return '%s %s' % (iFun,theRest)
1884 return '%s %s' % (iFun,theRest)
1887 if theRest.endswith(';'):
1885 if theRest.endswith(';'):
1888 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
1886 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
1889 else:
1887 else:
1890 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
1888 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
1891
1889
1892 print >>Term.cout, self.outputcache.prompt1.auto_rewrite() + newcmd
1890 print >>Term.cout, self.outputcache.prompt1.auto_rewrite() + newcmd
1893 # log what is now valid Python, not the actual user input (without the
1891 # log what is now valid Python, not the actual user input (without the
1894 # final newline)
1892 # final newline)
1895 self.log(newcmd,continue_prompt)
1893 self.log(newcmd,continue_prompt)
1896 return newcmd
1894 return newcmd
1897
1895
1898 def handle_help(self, line, continue_prompt=None,
1896 def handle_help(self, line, continue_prompt=None,
1899 pre=None,iFun=None,theRest=None):
1897 pre=None,iFun=None,theRest=None):
1900 """Try to get some help for the object.
1898 """Try to get some help for the object.
1901
1899
1902 obj? or ?obj -> basic information.
1900 obj? or ?obj -> basic information.
1903 obj?? or ??obj -> more details.
1901 obj?? or ??obj -> more details.
1904 """
1902 """
1905
1903
1906 # We need to make sure that we don't process lines which would be
1904 # We need to make sure that we don't process lines which would be
1907 # otherwise valid python, such as "x=1 # what?"
1905 # otherwise valid python, such as "x=1 # what?"
1908 try:
1906 try:
1909 codeop.compile_command(line)
1907 codeop.compile_command(line)
1910 except SyntaxError:
1908 except SyntaxError:
1911 # We should only handle as help stuff which is NOT valid syntax
1909 # We should only handle as help stuff which is NOT valid syntax
1912 if line[0]==self.ESC_HELP:
1910 if line[0]==self.ESC_HELP:
1913 line = line[1:]
1911 line = line[1:]
1914 elif line[-1]==self.ESC_HELP:
1912 elif line[-1]==self.ESC_HELP:
1915 line = line[:-1]
1913 line = line[:-1]
1916 self.log('#?'+line)
1914 self.log('#?'+line)
1917 if line:
1915 if line:
1918 self.magic_pinfo(line)
1916 self.magic_pinfo(line)
1919 else:
1917 else:
1920 page(self.usage,screen_lines=self.rc.screen_length)
1918 page(self.usage,screen_lines=self.rc.screen_length)
1921 return '' # Empty string is needed here!
1919 return '' # Empty string is needed here!
1922 except:
1920 except:
1923 # Pass any other exceptions through to the normal handler
1921 # Pass any other exceptions through to the normal handler
1924 return self.handle_normal(line,continue_prompt)
1922 return self.handle_normal(line,continue_prompt)
1925 else:
1923 else:
1926 # If the code compiles ok, we should handle it normally
1924 # If the code compiles ok, we should handle it normally
1927 return self.handle_normal(line,continue_prompt)
1925 return self.handle_normal(line,continue_prompt)
1928
1926
1929 def handle_emacs(self,line,continue_prompt=None,
1927 def handle_emacs(self,line,continue_prompt=None,
1930 pre=None,iFun=None,theRest=None):
1928 pre=None,iFun=None,theRest=None):
1931 """Handle input lines marked by python-mode."""
1929 """Handle input lines marked by python-mode."""
1932
1930
1933 # Currently, nothing is done. Later more functionality can be added
1931 # Currently, nothing is done. Later more functionality can be added
1934 # here if needed.
1932 # here if needed.
1935
1933
1936 # The input cache shouldn't be updated
1934 # The input cache shouldn't be updated
1937
1935
1938 return line
1936 return line
1939
1937
1940 def write(self,data):
1938 def write(self,data):
1941 """Write a string to the default output"""
1939 """Write a string to the default output"""
1942 Term.cout.write(data)
1940 Term.cout.write(data)
1943
1941
1944 def write_err(self,data):
1942 def write_err(self,data):
1945 """Write a string to the default error output"""
1943 """Write a string to the default error output"""
1946 Term.cerr.write(data)
1944 Term.cerr.write(data)
1947
1945
1948 def exit(self):
1946 def exit(self):
1949 """Handle interactive exit.
1947 """Handle interactive exit.
1950
1948
1951 This method sets the exit_now attribute."""
1949 This method sets the exit_now attribute."""
1952
1950
1953 if self.rc.confirm_exit:
1951 if self.rc.confirm_exit:
1954 if ask_yes_no('Do you really want to exit ([y]/n)?','y'):
1952 if ask_yes_no('Do you really want to exit ([y]/n)?','y'):
1955 self.exit_now = True
1953 self.exit_now = True
1956 else:
1954 else:
1957 self.exit_now = True
1955 self.exit_now = True
1958 return self.exit_now
1956 return self.exit_now
1959
1957
1960 def safe_execfile(self,fname,*where,**kw):
1958 def safe_execfile(self,fname,*where,**kw):
1961 fname = os.path.expanduser(fname)
1959 fname = os.path.expanduser(fname)
1962
1960
1963 # find things also in current directory
1961 # find things also in current directory
1964 dname = os.path.dirname(fname)
1962 dname = os.path.dirname(fname)
1965 if not sys.path.count(dname):
1963 if not sys.path.count(dname):
1966 sys.path.append(dname)
1964 sys.path.append(dname)
1967
1965
1968 try:
1966 try:
1969 xfile = open(fname)
1967 xfile = open(fname)
1970 except:
1968 except:
1971 print >> Term.cerr, \
1969 print >> Term.cerr, \
1972 'Could not open file <%s> for safe execution.' % fname
1970 'Could not open file <%s> for safe execution.' % fname
1973 return None
1971 return None
1974
1972
1975 kw.setdefault('islog',0)
1973 kw.setdefault('islog',0)
1976 kw.setdefault('quiet',1)
1974 kw.setdefault('quiet',1)
1977 kw.setdefault('exit_ignore',0)
1975 kw.setdefault('exit_ignore',0)
1978 first = xfile.readline()
1976 first = xfile.readline()
1979 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
1977 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
1980 xfile.close()
1978 xfile.close()
1981 # line by line execution
1979 # line by line execution
1982 if first.startswith(loghead) or kw['islog']:
1980 if first.startswith(loghead) or kw['islog']:
1983 print 'Loading log file <%s> one line at a time...' % fname
1981 print 'Loading log file <%s> one line at a time...' % fname
1984 if kw['quiet']:
1982 if kw['quiet']:
1985 stdout_save = sys.stdout
1983 stdout_save = sys.stdout
1986 sys.stdout = StringIO.StringIO()
1984 sys.stdout = StringIO.StringIO()
1987 try:
1985 try:
1988 globs,locs = where[0:2]
1986 globs,locs = where[0:2]
1989 except:
1987 except:
1990 try:
1988 try:
1991 globs = locs = where[0]
1989 globs = locs = where[0]
1992 except:
1990 except:
1993 globs = locs = globals()
1991 globs = locs = globals()
1994 badblocks = []
1992 badblocks = []
1995
1993
1996 # we also need to identify indented blocks of code when replaying
1994 # we also need to identify indented blocks of code when replaying
1997 # logs and put them together before passing them to an exec
1995 # logs and put them together before passing them to an exec
1998 # statement. This takes a bit of regexp and look-ahead work in the
1996 # statement. This takes a bit of regexp and look-ahead work in the
1999 # file. It's easiest if we swallow the whole thing in memory
1997 # file. It's easiest if we swallow the whole thing in memory
2000 # first, and manually walk through the lines list moving the
1998 # first, and manually walk through the lines list moving the
2001 # counter ourselves.
1999 # counter ourselves.
2002 indent_re = re.compile('\s+\S')
2000 indent_re = re.compile('\s+\S')
2003 xfile = open(fname)
2001 xfile = open(fname)
2004 filelines = xfile.readlines()
2002 filelines = xfile.readlines()
2005 xfile.close()
2003 xfile.close()
2006 nlines = len(filelines)
2004 nlines = len(filelines)
2007 lnum = 0
2005 lnum = 0
2008 while lnum < nlines:
2006 while lnum < nlines:
2009 line = filelines[lnum]
2007 line = filelines[lnum]
2010 lnum += 1
2008 lnum += 1
2011 # don't re-insert logger status info into cache
2009 # don't re-insert logger status info into cache
2012 if line.startswith('#log#'):
2010 if line.startswith('#log#'):
2013 continue
2011 continue
2014 else:
2012 else:
2015 # build a block of code (maybe a single line) for execution
2013 # build a block of code (maybe a single line) for execution
2016 block = line
2014 block = line
2017 try:
2015 try:
2018 next = filelines[lnum] # lnum has already incremented
2016 next = filelines[lnum] # lnum has already incremented
2019 except:
2017 except:
2020 next = None
2018 next = None
2021 while next and indent_re.match(next):
2019 while next and indent_re.match(next):
2022 block += next
2020 block += next
2023 lnum += 1
2021 lnum += 1
2024 try:
2022 try:
2025 next = filelines[lnum]
2023 next = filelines[lnum]
2026 except:
2024 except:
2027 next = None
2025 next = None
2028 # now execute the block of one or more lines
2026 # now execute the block of one or more lines
2029 try:
2027 try:
2030 exec block in globs,locs
2028 exec block in globs,locs
2031 except SystemExit:
2029 except SystemExit:
2032 pass
2030 pass
2033 except:
2031 except:
2034 badblocks.append(block.rstrip())
2032 badblocks.append(block.rstrip())
2035 if kw['quiet']: # restore stdout
2033 if kw['quiet']: # restore stdout
2036 sys.stdout.close()
2034 sys.stdout.close()
2037 sys.stdout = stdout_save
2035 sys.stdout = stdout_save
2038 print 'Finished replaying log file <%s>' % fname
2036 print 'Finished replaying log file <%s>' % fname
2039 if badblocks:
2037 if badblocks:
2040 print >> sys.stderr, ('\nThe following lines/blocks in file '
2038 print >> sys.stderr, ('\nThe following lines/blocks in file '
2041 '<%s> reported errors:' % fname)
2039 '<%s> reported errors:' % fname)
2042
2040
2043 for badline in badblocks:
2041 for badline in badblocks:
2044 print >> sys.stderr, badline
2042 print >> sys.stderr, badline
2045 else: # regular file execution
2043 else: # regular file execution
2046 try:
2044 try:
2047 execfile(fname,*where)
2045 execfile(fname,*where)
2048 except SyntaxError:
2046 except SyntaxError:
2049 etype,evalue = sys.exc_info()[:2]
2047 etype,evalue = sys.exc_info()[:2]
2050 self.SyntaxTB(etype,evalue,[])
2048 self.SyntaxTB(etype,evalue,[])
2051 warn('Failure executing file: <%s>' % fname)
2049 warn('Failure executing file: <%s>' % fname)
2052 except SystemExit,status:
2050 except SystemExit,status:
2053 if not kw['exit_ignore']:
2051 if not kw['exit_ignore']:
2054 self.InteractiveTB()
2052 self.InteractiveTB()
2055 warn('Failure executing file: <%s>' % fname)
2053 warn('Failure executing file: <%s>' % fname)
2056 except:
2054 except:
2057 self.InteractiveTB()
2055 self.InteractiveTB()
2058 warn('Failure executing file: <%s>' % fname)
2056 warn('Failure executing file: <%s>' % fname)
2059
2057
2060 #************************* end of file <iplib.py> *****************************
2058 #************************* end of file <iplib.py> *****************************
1 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now