##// END OF EJS Templates
- New dtutils module for running doctests interactively with more...
fperez -
Show More

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

@@ -0,0 +1,137
1 """Doctest-related utilities for IPython.
2
3 For most common uses, all you should need to run is::
4
5 from IPython.dtutils import idoctest
6
7 See the idoctest docstring below for usage details.
8 """
9
10 import doctest
11 import sys
12
13 import IPython.ipapi
14 ip = IPython.ipapi.get()
15
16 def rundoctest(text,ns=None,eraise=False):
17 """Run a the input source as a doctest, in the caller's namespace.
18
19 :Parameters:
20 text : str
21 Source to execute.
22
23 :Keywords:
24 ns : dict (None)
25 Namespace where the code should be executed. If not given, the
26 caller's locals and globals are used.
27 eraise : bool (False)
28 If true, immediately raise any exceptions instead of reporting them at
29 the end. This allows you to then do interactive debugging via
30 IPython's facilities (use %debug after the fact, or with %pdb for
31 automatic activation).
32 """
33
34 name = 'interactive doctest'
35 filename = '<IPython console>'
36
37 if eraise:
38 runner = doctest.DebugRunner()
39 else:
40 runner = doctest.DocTestRunner()
41
42 parser = doctest.DocTestParser()
43 if ns is None:
44 f = sys._getframe(1)
45 ns = f.f_globals.copy()
46 ns.update(f.f_locals)
47
48 test = parser.get_doctest(text,ns,name,filename,0)
49 runner.run(test)
50 runner.summarize(True)
51
52
53 def idoctest(ns=None,eraise=False):
54 """Interactively prompt for input and run it as a doctest.
55
56 To finish entering input, enter two blank lines or Ctrl-D (EOF). If you
57 use Ctrl-C, the example is aborted and all input discarded.
58
59 :Keywords:
60 ns : dict (None)
61 Namespace where the code should be executed. If not given, the IPython
62 interactive namespace is used.
63 eraise : bool (False)
64 If true, immediately raise any exceptions instead of reporting them at
65 the end. This allows you to then do interactive debugging via
66 IPython's facilities (use %debug after the fact, or with %pdb for
67 automatic activation).
68 end_mark : str ('--')
69 String to explicitly indicate the end of input.
70
71 """
72
73 inlines = []
74 empty_lines = 0 # count consecutive empty lines
75 run_test = True
76
77 if ns is None:
78 ns = ip.user_ns
79
80 ip.IP.savehist()
81 try:
82 while True:
83 line = raw_input()
84 if not line or line.isspace():
85 empty_lines += 1
86 else:
87 empty_lines = 0
88
89 if empty_lines>=2:
90 break
91
92 inlines.append(line)
93 except EOFError:
94 pass
95 except KeyboardInterrupt:
96 print "KeyboardInterrupt - Discarding input."
97 run_test = False
98
99 ip.IP.reloadhist()
100
101 if run_test:
102 # Extra blank line at the end to ensure that the final docstring has a
103 # closing newline
104 inlines.append('')
105 rundoctest('\n'.join(inlines),ns,eraise)
106
107
108 # For debugging of this module itself.
109 if __name__ == "__main__":
110 t = """
111 >>> for i in range(10):
112 ... print i,
113 ...
114 0 1 2 3 4 5 6 7 8 9
115 """
116
117 t2 = """
118 A simple example::
119
120 >>> for i in range(10):
121 ... print i,
122 ...
123 0 1 2 3 4 5 6 7 8 9
124
125 Some more details::
126
127 >>> print "hello"
128 hello
129 """
130
131 t3 = """
132 A failing example::
133
134 >>> x=1
135 >>> x+1
136 3
137 """
@@ -1,3273 +1,3272
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Magic functions for InteractiveShell.
2 """Magic functions for InteractiveShell.
3
3
4 $Id: Magic.py 2874 2007-11-26 06:50:42Z fperez $"""
4 $Id: Magic.py 2899 2007-12-28 08:32:59Z 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-2006 Fernando Perez <fperez@colorado.edu>
8 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
9 #
9 #
10 # Distributed under the terms of the BSD License. The full license is in
10 # Distributed under the terms of the BSD License. The full license is in
11 # the file COPYING, distributed as part of this software.
11 # the file COPYING, distributed as part of this software.
12 #*****************************************************************************
12 #*****************************************************************************
13
13
14 #****************************************************************************
14 #****************************************************************************
15 # Modules and globals
15 # Modules and globals
16
16
17 from IPython import Release
17 from IPython import Release
18 __author__ = '%s <%s>\n%s <%s>' % \
18 __author__ = '%s <%s>\n%s <%s>' % \
19 ( Release.authors['Janko'] + Release.authors['Fernando'] )
19 ( Release.authors['Janko'] + Release.authors['Fernando'] )
20 __license__ = Release.license
20 __license__ = Release.license
21
21
22 # Python standard modules
22 # Python standard modules
23 import __builtin__
23 import __builtin__
24 import bdb
24 import bdb
25 import inspect
25 import inspect
26 import os
26 import os
27 import pdb
27 import pdb
28 import pydoc
28 import pydoc
29 import sys
29 import sys
30 import re
30 import re
31 import tempfile
31 import tempfile
32 import time
32 import time
33 import cPickle as pickle
33 import cPickle as pickle
34 import textwrap
34 import textwrap
35 from cStringIO import StringIO
35 from cStringIO import StringIO
36 from getopt import getopt,GetoptError
36 from getopt import getopt,GetoptError
37 from pprint import pprint, pformat
37 from pprint import pprint, pformat
38 from sets import Set
38 from sets import Set
39
39
40 # cProfile was added in Python2.5
40 # cProfile was added in Python2.5
41 try:
41 try:
42 import cProfile as profile
42 import cProfile as profile
43 import pstats
43 import pstats
44 except ImportError:
44 except ImportError:
45 # profile isn't bundled by default in Debian for license reasons
45 # profile isn't bundled by default in Debian for license reasons
46 try:
46 try:
47 import profile,pstats
47 import profile,pstats
48 except ImportError:
48 except ImportError:
49 profile = pstats = None
49 profile = pstats = None
50
50
51 # Homebrewed
51 # Homebrewed
52 import IPython
52 import IPython
53 from IPython import Debugger, OInspect, wildcard
53 from IPython import Debugger, OInspect, wildcard
54 from IPython.FakeModule import FakeModule
54 from IPython.FakeModule import FakeModule
55 from IPython.Itpl import Itpl, itpl, printpl,itplns
55 from IPython.Itpl import Itpl, itpl, printpl,itplns
56 from IPython.PyColorize import Parser
56 from IPython.PyColorize import Parser
57 from IPython.ipstruct import Struct
57 from IPython.ipstruct import Struct
58 from IPython.macro import Macro
58 from IPython.macro import Macro
59 from IPython.genutils import *
59 from IPython.genutils import *
60 from IPython import platutils
60 from IPython import platutils
61 import IPython.generics
61 import IPython.generics
62 import IPython.ipapi
62 import IPython.ipapi
63 from IPython.ipapi import UsageError
63 from IPython.ipapi import UsageError
64 #***************************************************************************
64 #***************************************************************************
65 # Utility functions
65 # Utility functions
66 def on_off(tag):
66 def on_off(tag):
67 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
67 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
68 return ['OFF','ON'][tag]
68 return ['OFF','ON'][tag]
69
69
70 class Bunch: pass
70 class Bunch: pass
71
71
72 def compress_dhist(dh):
72 def compress_dhist(dh):
73 head, tail = dh[:-10], dh[-10:]
73 head, tail = dh[:-10], dh[-10:]
74
74
75 newhead = []
75 newhead = []
76 done = Set()
76 done = Set()
77 for h in head:
77 for h in head:
78 if h in done:
78 if h in done:
79 continue
79 continue
80 newhead.append(h)
80 newhead.append(h)
81 done.add(h)
81 done.add(h)
82
82
83 return newhead + tail
83 return newhead + tail
84
84
85
85
86 #***************************************************************************
86 #***************************************************************************
87 # Main class implementing Magic functionality
87 # Main class implementing Magic functionality
88 class Magic:
88 class Magic:
89 """Magic functions for InteractiveShell.
89 """Magic functions for InteractiveShell.
90
90
91 Shell functions which can be reached as %function_name. All magic
91 Shell functions which can be reached as %function_name. All magic
92 functions should accept a string, which they can parse for their own
92 functions should accept a string, which they can parse for their own
93 needs. This can make some functions easier to type, eg `%cd ../`
93 needs. This can make some functions easier to type, eg `%cd ../`
94 vs. `%cd("../")`
94 vs. `%cd("../")`
95
95
96 ALL definitions MUST begin with the prefix magic_. The user won't need it
96 ALL definitions MUST begin with the prefix magic_. The user won't need it
97 at the command line, but it is is needed in the definition. """
97 at the command line, but it is is needed in the definition. """
98
98
99 # class globals
99 # class globals
100 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
100 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
101 'Automagic is ON, % prefix NOT needed for magic functions.']
101 'Automagic is ON, % prefix NOT needed for magic functions.']
102
102
103 #......................................................................
103 #......................................................................
104 # some utility functions
104 # some utility functions
105
105
106 def __init__(self,shell):
106 def __init__(self,shell):
107
107
108 self.options_table = {}
108 self.options_table = {}
109 if profile is None:
109 if profile is None:
110 self.magic_prun = self.profile_missing_notice
110 self.magic_prun = self.profile_missing_notice
111 self.shell = shell
111 self.shell = shell
112
112
113 # namespace for holding state we may need
113 # namespace for holding state we may need
114 self._magic_state = Bunch()
114 self._magic_state = Bunch()
115
115
116 def profile_missing_notice(self, *args, **kwargs):
116 def profile_missing_notice(self, *args, **kwargs):
117 error("""\
117 error("""\
118 The profile module could not be found. If you are a Debian user,
118 The profile module could not be found. If you are a Debian user,
119 it has been removed from the standard Debian package because of its non-free
119 it has been removed from the standard Debian package because of its non-free
120 license. To use profiling, please install"python2.3-profiler" from non-free.""")
120 license. To use profiling, please install"python2.3-profiler" from non-free.""")
121
121
122 def default_option(self,fn,optstr):
122 def default_option(self,fn,optstr):
123 """Make an entry in the options_table for fn, with value optstr"""
123 """Make an entry in the options_table for fn, with value optstr"""
124
124
125 if fn not in self.lsmagic():
125 if fn not in self.lsmagic():
126 error("%s is not a magic function" % fn)
126 error("%s is not a magic function" % fn)
127 self.options_table[fn] = optstr
127 self.options_table[fn] = optstr
128
128
129 def lsmagic(self):
129 def lsmagic(self):
130 """Return a list of currently available magic functions.
130 """Return a list of currently available magic functions.
131
131
132 Gives a list of the bare names after mangling (['ls','cd', ...], not
132 Gives a list of the bare names after mangling (['ls','cd', ...], not
133 ['magic_ls','magic_cd',...]"""
133 ['magic_ls','magic_cd',...]"""
134
134
135 # FIXME. This needs a cleanup, in the way the magics list is built.
135 # FIXME. This needs a cleanup, in the way the magics list is built.
136
136
137 # magics in class definition
137 # magics in class definition
138 class_magic = lambda fn: fn.startswith('magic_') and \
138 class_magic = lambda fn: fn.startswith('magic_') and \
139 callable(Magic.__dict__[fn])
139 callable(Magic.__dict__[fn])
140 # in instance namespace (run-time user additions)
140 # in instance namespace (run-time user additions)
141 inst_magic = lambda fn: fn.startswith('magic_') and \
141 inst_magic = lambda fn: fn.startswith('magic_') and \
142 callable(self.__dict__[fn])
142 callable(self.__dict__[fn])
143 # and bound magics by user (so they can access self):
143 # and bound magics by user (so they can access self):
144 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
144 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
145 callable(self.__class__.__dict__[fn])
145 callable(self.__class__.__dict__[fn])
146 magics = filter(class_magic,Magic.__dict__.keys()) + \
146 magics = filter(class_magic,Magic.__dict__.keys()) + \
147 filter(inst_magic,self.__dict__.keys()) + \
147 filter(inst_magic,self.__dict__.keys()) + \
148 filter(inst_bound_magic,self.__class__.__dict__.keys())
148 filter(inst_bound_magic,self.__class__.__dict__.keys())
149 out = []
149 out = []
150 for fn in magics:
150 for fn in magics:
151 out.append(fn.replace('magic_','',1))
151 out.append(fn.replace('magic_','',1))
152 out.sort()
152 out.sort()
153 return out
153 return out
154
154
155 def extract_input_slices(self,slices,raw=False):
155 def extract_input_slices(self,slices,raw=False):
156 """Return as a string a set of input history slices.
156 """Return as a string a set of input history slices.
157
157
158 Inputs:
158 Inputs:
159
159
160 - slices: the set of slices is given as a list of strings (like
160 - slices: the set of slices is given as a list of strings (like
161 ['1','4:8','9'], since this function is for use by magic functions
161 ['1','4:8','9'], since this function is for use by magic functions
162 which get their arguments as strings.
162 which get their arguments as strings.
163
163
164 Optional inputs:
164 Optional inputs:
165
165
166 - raw(False): by default, the processed input is used. If this is
166 - raw(False): by default, the processed input is used. If this is
167 true, the raw input history is used instead.
167 true, the raw input history is used instead.
168
168
169 Note that slices can be called with two notations:
169 Note that slices can be called with two notations:
170
170
171 N:M -> standard python form, means including items N...(M-1).
171 N:M -> standard python form, means including items N...(M-1).
172
172
173 N-M -> include items N..M (closed endpoint)."""
173 N-M -> include items N..M (closed endpoint)."""
174
174
175 if raw:
175 if raw:
176 hist = self.shell.input_hist_raw
176 hist = self.shell.input_hist_raw
177 else:
177 else:
178 hist = self.shell.input_hist
178 hist = self.shell.input_hist
179
179
180 cmds = []
180 cmds = []
181 for chunk in slices:
181 for chunk in slices:
182 if ':' in chunk:
182 if ':' in chunk:
183 ini,fin = map(int,chunk.split(':'))
183 ini,fin = map(int,chunk.split(':'))
184 elif '-' in chunk:
184 elif '-' in chunk:
185 ini,fin = map(int,chunk.split('-'))
185 ini,fin = map(int,chunk.split('-'))
186 fin += 1
186 fin += 1
187 else:
187 else:
188 ini = int(chunk)
188 ini = int(chunk)
189 fin = ini+1
189 fin = ini+1
190 cmds.append(hist[ini:fin])
190 cmds.append(hist[ini:fin])
191 return cmds
191 return cmds
192
192
193 def _ofind(self, oname, namespaces=None):
193 def _ofind(self, oname, namespaces=None):
194 """Find an object in the available namespaces.
194 """Find an object in the available namespaces.
195
195
196 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
196 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
197
197
198 Has special code to detect magic functions.
198 Has special code to detect magic functions.
199 """
199 """
200
200
201 oname = oname.strip()
201 oname = oname.strip()
202
202
203 alias_ns = None
203 alias_ns = None
204 if namespaces is None:
204 if namespaces is None:
205 # Namespaces to search in:
205 # Namespaces to search in:
206 # Put them in a list. The order is important so that we
206 # Put them in a list. The order is important so that we
207 # find things in the same order that Python finds them.
207 # find things in the same order that Python finds them.
208 namespaces = [ ('Interactive', self.shell.user_ns),
208 namespaces = [ ('Interactive', self.shell.user_ns),
209 ('IPython internal', self.shell.internal_ns),
209 ('IPython internal', self.shell.internal_ns),
210 ('Python builtin', __builtin__.__dict__),
210 ('Python builtin', __builtin__.__dict__),
211 ('Alias', self.shell.alias_table),
211 ('Alias', self.shell.alias_table),
212 ]
212 ]
213 alias_ns = self.shell.alias_table
213 alias_ns = self.shell.alias_table
214
214
215 # initialize results to 'null'
215 # initialize results to 'null'
216 found = 0; obj = None; ospace = None; ds = None;
216 found = 0; obj = None; ospace = None; ds = None;
217 ismagic = 0; isalias = 0; parent = None
217 ismagic = 0; isalias = 0; parent = None
218
218
219 # Look for the given name by splitting it in parts. If the head is
219 # Look for the given name by splitting it in parts. If the head is
220 # found, then we look for all the remaining parts as members, and only
220 # found, then we look for all the remaining parts as members, and only
221 # declare success if we can find them all.
221 # declare success if we can find them all.
222 oname_parts = oname.split('.')
222 oname_parts = oname.split('.')
223 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
223 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
224 for nsname,ns in namespaces:
224 for nsname,ns in namespaces:
225 try:
225 try:
226 obj = ns[oname_head]
226 obj = ns[oname_head]
227 except KeyError:
227 except KeyError:
228 continue
228 continue
229 else:
229 else:
230 #print 'oname_rest:', oname_rest # dbg
230 #print 'oname_rest:', oname_rest # dbg
231 for part in oname_rest:
231 for part in oname_rest:
232 try:
232 try:
233 parent = obj
233 parent = obj
234 obj = getattr(obj,part)
234 obj = getattr(obj,part)
235 except:
235 except:
236 # Blanket except b/c some badly implemented objects
236 # Blanket except b/c some badly implemented objects
237 # allow __getattr__ to raise exceptions other than
237 # allow __getattr__ to raise exceptions other than
238 # AttributeError, which then crashes IPython.
238 # AttributeError, which then crashes IPython.
239 break
239 break
240 else:
240 else:
241 # If we finish the for loop (no break), we got all members
241 # If we finish the for loop (no break), we got all members
242 found = 1
242 found = 1
243 ospace = nsname
243 ospace = nsname
244 if ns == alias_ns:
244 if ns == alias_ns:
245 isalias = 1
245 isalias = 1
246 break # namespace loop
246 break # namespace loop
247
247
248 # Try to see if it's magic
248 # Try to see if it's magic
249 if not found:
249 if not found:
250 if oname.startswith(self.shell.ESC_MAGIC):
250 if oname.startswith(self.shell.ESC_MAGIC):
251 oname = oname[1:]
251 oname = oname[1:]
252 obj = getattr(self,'magic_'+oname,None)
252 obj = getattr(self,'magic_'+oname,None)
253 if obj is not None:
253 if obj is not None:
254 found = 1
254 found = 1
255 ospace = 'IPython internal'
255 ospace = 'IPython internal'
256 ismagic = 1
256 ismagic = 1
257
257
258 # Last try: special-case some literals like '', [], {}, etc:
258 # Last try: special-case some literals like '', [], {}, etc:
259 if not found and oname_head in ["''",'""','[]','{}','()']:
259 if not found and oname_head in ["''",'""','[]','{}','()']:
260 obj = eval(oname_head)
260 obj = eval(oname_head)
261 found = 1
261 found = 1
262 ospace = 'Interactive'
262 ospace = 'Interactive'
263
263
264 return {'found':found, 'obj':obj, 'namespace':ospace,
264 return {'found':found, 'obj':obj, 'namespace':ospace,
265 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
265 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
266
266
267 def arg_err(self,func):
267 def arg_err(self,func):
268 """Print docstring if incorrect arguments were passed"""
268 """Print docstring if incorrect arguments were passed"""
269 print 'Error in arguments:'
269 print 'Error in arguments:'
270 print OInspect.getdoc(func)
270 print OInspect.getdoc(func)
271
271
272 def format_latex(self,strng):
272 def format_latex(self,strng):
273 """Format a string for latex inclusion."""
273 """Format a string for latex inclusion."""
274
274
275 # Characters that need to be escaped for latex:
275 # Characters that need to be escaped for latex:
276 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
276 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
277 # Magic command names as headers:
277 # Magic command names as headers:
278 cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
278 cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
279 re.MULTILINE)
279 re.MULTILINE)
280 # Magic commands
280 # Magic commands
281 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
281 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
282 re.MULTILINE)
282 re.MULTILINE)
283 # Paragraph continue
283 # Paragraph continue
284 par_re = re.compile(r'\\$',re.MULTILINE)
284 par_re = re.compile(r'\\$',re.MULTILINE)
285
285
286 # The "\n" symbol
286 # The "\n" symbol
287 newline_re = re.compile(r'\\n')
287 newline_re = re.compile(r'\\n')
288
288
289 # Now build the string for output:
289 # Now build the string for output:
290 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
290 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
291 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
291 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
292 strng)
292 strng)
293 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
293 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
294 strng = par_re.sub(r'\\\\',strng)
294 strng = par_re.sub(r'\\\\',strng)
295 strng = escape_re.sub(r'\\\1',strng)
295 strng = escape_re.sub(r'\\\1',strng)
296 strng = newline_re.sub(r'\\textbackslash{}n',strng)
296 strng = newline_re.sub(r'\\textbackslash{}n',strng)
297 return strng
297 return strng
298
298
299 def format_screen(self,strng):
299 def format_screen(self,strng):
300 """Format a string for screen printing.
300 """Format a string for screen printing.
301
301
302 This removes some latex-type format codes."""
302 This removes some latex-type format codes."""
303 # Paragraph continue
303 # Paragraph continue
304 par_re = re.compile(r'\\$',re.MULTILINE)
304 par_re = re.compile(r'\\$',re.MULTILINE)
305 strng = par_re.sub('',strng)
305 strng = par_re.sub('',strng)
306 return strng
306 return strng
307
307
308 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
308 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
309 """Parse options passed to an argument string.
309 """Parse options passed to an argument string.
310
310
311 The interface is similar to that of getopt(), but it returns back a
311 The interface is similar to that of getopt(), but it returns back a
312 Struct with the options as keys and the stripped argument string still
312 Struct with the options as keys and the stripped argument string still
313 as a string.
313 as a string.
314
314
315 arg_str is quoted as a true sys.argv vector by using shlex.split.
315 arg_str is quoted as a true sys.argv vector by using shlex.split.
316 This allows us to easily expand variables, glob files, quote
316 This allows us to easily expand variables, glob files, quote
317 arguments, etc.
317 arguments, etc.
318
318
319 Options:
319 Options:
320 -mode: default 'string'. If given as 'list', the argument string is
320 -mode: default 'string'. If given as 'list', the argument string is
321 returned as a list (split on whitespace) instead of a string.
321 returned as a list (split on whitespace) instead of a string.
322
322
323 -list_all: put all option values in lists. Normally only options
323 -list_all: put all option values in lists. Normally only options
324 appearing more than once are put in a list.
324 appearing more than once are put in a list.
325
325
326 -posix (True): whether to split the input line in POSIX mode or not,
326 -posix (True): whether to split the input line in POSIX mode or not,
327 as per the conventions outlined in the shlex module from the
327 as per the conventions outlined in the shlex module from the
328 standard library."""
328 standard library."""
329
329
330 # inject default options at the beginning of the input line
330 # inject default options at the beginning of the input line
331 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
331 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
332 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
332 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
333
333
334 mode = kw.get('mode','string')
334 mode = kw.get('mode','string')
335 if mode not in ['string','list']:
335 if mode not in ['string','list']:
336 raise ValueError,'incorrect mode given: %s' % mode
336 raise ValueError,'incorrect mode given: %s' % mode
337 # Get options
337 # Get options
338 list_all = kw.get('list_all',0)
338 list_all = kw.get('list_all',0)
339 posix = kw.get('posix',True)
339 posix = kw.get('posix',True)
340
340
341 # Check if we have more than one argument to warrant extra processing:
341 # Check if we have more than one argument to warrant extra processing:
342 odict = {} # Dictionary with options
342 odict = {} # Dictionary with options
343 args = arg_str.split()
343 args = arg_str.split()
344 if len(args) >= 1:
344 if len(args) >= 1:
345 # If the list of inputs only has 0 or 1 thing in it, there's no
345 # If the list of inputs only has 0 or 1 thing in it, there's no
346 # need to look for options
346 # need to look for options
347 argv = arg_split(arg_str,posix)
347 argv = arg_split(arg_str,posix)
348 # Do regular option processing
348 # Do regular option processing
349 try:
349 try:
350 opts,args = getopt(argv,opt_str,*long_opts)
350 opts,args = getopt(argv,opt_str,*long_opts)
351 except GetoptError,e:
351 except GetoptError,e:
352 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
352 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
353 " ".join(long_opts)))
353 " ".join(long_opts)))
354 for o,a in opts:
354 for o,a in opts:
355 if o.startswith('--'):
355 if o.startswith('--'):
356 o = o[2:]
356 o = o[2:]
357 else:
357 else:
358 o = o[1:]
358 o = o[1:]
359 try:
359 try:
360 odict[o].append(a)
360 odict[o].append(a)
361 except AttributeError:
361 except AttributeError:
362 odict[o] = [odict[o],a]
362 odict[o] = [odict[o],a]
363 except KeyError:
363 except KeyError:
364 if list_all:
364 if list_all:
365 odict[o] = [a]
365 odict[o] = [a]
366 else:
366 else:
367 odict[o] = a
367 odict[o] = a
368
368
369 # Prepare opts,args for return
369 # Prepare opts,args for return
370 opts = Struct(odict)
370 opts = Struct(odict)
371 if mode == 'string':
371 if mode == 'string':
372 args = ' '.join(args)
372 args = ' '.join(args)
373
373
374 return opts,args
374 return opts,args
375
375
376 #......................................................................
376 #......................................................................
377 # And now the actual magic functions
377 # And now the actual magic functions
378
378
379 # Functions for IPython shell work (vars,funcs, config, etc)
379 # Functions for IPython shell work (vars,funcs, config, etc)
380 def magic_lsmagic(self, parameter_s = ''):
380 def magic_lsmagic(self, parameter_s = ''):
381 """List currently available magic functions."""
381 """List currently available magic functions."""
382 mesc = self.shell.ESC_MAGIC
382 mesc = self.shell.ESC_MAGIC
383 print 'Available magic functions:\n'+mesc+\
383 print 'Available magic functions:\n'+mesc+\
384 (' '+mesc).join(self.lsmagic())
384 (' '+mesc).join(self.lsmagic())
385 print '\n' + Magic.auto_status[self.shell.rc.automagic]
385 print '\n' + Magic.auto_status[self.shell.rc.automagic]
386 return None
386 return None
387
387
388 def magic_magic(self, parameter_s = ''):
388 def magic_magic(self, parameter_s = ''):
389 """Print information about the magic function system."""
389 """Print information about the magic function system."""
390
390
391 mode = ''
391 mode = ''
392 try:
392 try:
393 if parameter_s.split()[0] == '-latex':
393 if parameter_s.split()[0] == '-latex':
394 mode = 'latex'
394 mode = 'latex'
395 if parameter_s.split()[0] == '-brief':
395 if parameter_s.split()[0] == '-brief':
396 mode = 'brief'
396 mode = 'brief'
397 except:
397 except:
398 pass
398 pass
399
399
400 magic_docs = []
400 magic_docs = []
401 for fname in self.lsmagic():
401 for fname in self.lsmagic():
402 mname = 'magic_' + fname
402 mname = 'magic_' + fname
403 for space in (Magic,self,self.__class__):
403 for space in (Magic,self,self.__class__):
404 try:
404 try:
405 fn = space.__dict__[mname]
405 fn = space.__dict__[mname]
406 except KeyError:
406 except KeyError:
407 pass
407 pass
408 else:
408 else:
409 break
409 break
410 if mode == 'brief':
410 if mode == 'brief':
411 # only first line
411 # only first line
412 fndoc = fn.__doc__.split('\n',1)[0]
412 fndoc = fn.__doc__.split('\n',1)[0]
413 else:
413 else:
414 fndoc = fn.__doc__
414 fndoc = fn.__doc__
415
415
416 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
416 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
417 fname,fndoc))
417 fname,fndoc))
418 magic_docs = ''.join(magic_docs)
418 magic_docs = ''.join(magic_docs)
419
419
420 if mode == 'latex':
420 if mode == 'latex':
421 print self.format_latex(magic_docs)
421 print self.format_latex(magic_docs)
422 return
422 return
423 else:
423 else:
424 magic_docs = self.format_screen(magic_docs)
424 magic_docs = self.format_screen(magic_docs)
425 if mode == 'brief':
425 if mode == 'brief':
426 return magic_docs
426 return magic_docs
427
427
428 outmsg = """
428 outmsg = """
429 IPython's 'magic' functions
429 IPython's 'magic' functions
430 ===========================
430 ===========================
431
431
432 The magic function system provides a series of functions which allow you to
432 The magic function system provides a series of functions which allow you to
433 control the behavior of IPython itself, plus a lot of system-type
433 control the behavior of IPython itself, plus a lot of system-type
434 features. All these functions are prefixed with a % character, but parameters
434 features. All these functions are prefixed with a % character, but parameters
435 are given without parentheses or quotes.
435 are given without parentheses or quotes.
436
436
437 NOTE: If you have 'automagic' enabled (via the command line option or with the
437 NOTE: If you have 'automagic' enabled (via the command line option or with the
438 %automagic function), you don't need to type in the % explicitly. By default,
438 %automagic function), you don't need to type in the % explicitly. By default,
439 IPython ships with automagic on, so you should only rarely need the % escape.
439 IPython ships with automagic on, so you should only rarely need the % escape.
440
440
441 Example: typing '%cd mydir' (without the quotes) changes you working directory
441 Example: typing '%cd mydir' (without the quotes) changes you working directory
442 to 'mydir', if it exists.
442 to 'mydir', if it exists.
443
443
444 You can define your own magic functions to extend the system. See the supplied
444 You can define your own magic functions to extend the system. See the supplied
445 ipythonrc and example-magic.py files for details (in your ipython
445 ipythonrc and example-magic.py files for details (in your ipython
446 configuration directory, typically $HOME/.ipython/).
446 configuration directory, typically $HOME/.ipython/).
447
447
448 You can also define your own aliased names for magic functions. In your
448 You can also define your own aliased names for magic functions. In your
449 ipythonrc file, placing a line like:
449 ipythonrc file, placing a line like:
450
450
451 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
451 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
452
452
453 will define %pf as a new name for %profile.
453 will define %pf as a new name for %profile.
454
454
455 You can also call magics in code using the ipmagic() function, which IPython
455 You can also call magics in code using the ipmagic() function, which IPython
456 automatically adds to the builtin namespace. Type 'ipmagic?' for details.
456 automatically adds to the builtin namespace. Type 'ipmagic?' for details.
457
457
458 For a list of the available magic functions, use %lsmagic. For a description
458 For a list of the available magic functions, use %lsmagic. For a description
459 of any of them, type %magic_name?, e.g. '%cd?'.
459 of any of them, type %magic_name?, e.g. '%cd?'.
460
460
461 Currently the magic system has the following functions:\n"""
461 Currently the magic system has the following functions:\n"""
462
462
463 mesc = self.shell.ESC_MAGIC
463 mesc = self.shell.ESC_MAGIC
464 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
464 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
465 "\n\n%s%s\n\n%s" % (outmsg,
465 "\n\n%s%s\n\n%s" % (outmsg,
466 magic_docs,mesc,mesc,
466 magic_docs,mesc,mesc,
467 (' '+mesc).join(self.lsmagic()),
467 (' '+mesc).join(self.lsmagic()),
468 Magic.auto_status[self.shell.rc.automagic] ) )
468 Magic.auto_status[self.shell.rc.automagic] ) )
469
469
470 page(outmsg,screen_lines=self.shell.rc.screen_length)
470 page(outmsg,screen_lines=self.shell.rc.screen_length)
471
471
472
472
473 def magic_autoindent(self, parameter_s = ''):
473 def magic_autoindent(self, parameter_s = ''):
474 """Toggle autoindent on/off (if available)."""
474 """Toggle autoindent on/off (if available)."""
475
475
476 self.shell.set_autoindent()
476 self.shell.set_autoindent()
477 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
477 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
478
478
479
479
480 def magic_automagic(self, parameter_s = ''):
480 def magic_automagic(self, parameter_s = ''):
481 """Make magic functions callable without having to type the initial %.
481 """Make magic functions callable without having to type the initial %.
482
482
483 Without argumentsl toggles on/off (when off, you must call it as
483 Without argumentsl toggles on/off (when off, you must call it as
484 %automagic, of course). With arguments it sets the value, and you can
484 %automagic, of course). With arguments it sets the value, and you can
485 use any of (case insensitive):
485 use any of (case insensitive):
486
486
487 - on,1,True: to activate
487 - on,1,True: to activate
488
488
489 - off,0,False: to deactivate.
489 - off,0,False: to deactivate.
490
490
491 Note that magic functions have lowest priority, so if there's a
491 Note that magic functions have lowest priority, so if there's a
492 variable whose name collides with that of a magic fn, automagic won't
492 variable whose name collides with that of a magic fn, automagic won't
493 work for that function (you get the variable instead). However, if you
493 work for that function (you get the variable instead). However, if you
494 delete the variable (del var), the previously shadowed magic function
494 delete the variable (del var), the previously shadowed magic function
495 becomes visible to automagic again."""
495 becomes visible to automagic again."""
496
496
497 rc = self.shell.rc
497 rc = self.shell.rc
498 arg = parameter_s.lower()
498 arg = parameter_s.lower()
499 if parameter_s in ('on','1','true'):
499 if parameter_s in ('on','1','true'):
500 rc.automagic = True
500 rc.automagic = True
501 elif parameter_s in ('off','0','false'):
501 elif parameter_s in ('off','0','false'):
502 rc.automagic = False
502 rc.automagic = False
503 else:
503 else:
504 rc.automagic = not rc.automagic
504 rc.automagic = not rc.automagic
505 print '\n' + Magic.auto_status[rc.automagic]
505 print '\n' + Magic.auto_status[rc.automagic]
506
506
507
507
508 def magic_autocall(self, parameter_s = ''):
508 def magic_autocall(self, parameter_s = ''):
509 """Make functions callable without having to type parentheses.
509 """Make functions callable without having to type parentheses.
510
510
511 Usage:
511 Usage:
512
512
513 %autocall [mode]
513 %autocall [mode]
514
514
515 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
515 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
516 value is toggled on and off (remembering the previous state).
516 value is toggled on and off (remembering the previous state).
517
517
518 In more detail, these values mean:
518 In more detail, these values mean:
519
519
520 0 -> fully disabled
520 0 -> fully disabled
521
521
522 1 -> active, but do not apply if there are no arguments on the line.
522 1 -> active, but do not apply if there are no arguments on the line.
523
523
524 In this mode, you get:
524 In this mode, you get:
525
525
526 In [1]: callable
526 In [1]: callable
527 Out[1]: <built-in function callable>
527 Out[1]: <built-in function callable>
528
528
529 In [2]: callable 'hello'
529 In [2]: callable 'hello'
530 ------> callable('hello')
530 ------> callable('hello')
531 Out[2]: False
531 Out[2]: False
532
532
533 2 -> Active always. Even if no arguments are present, the callable
533 2 -> Active always. Even if no arguments are present, the callable
534 object is called:
534 object is called:
535
535
536 In [4]: callable
536 In [4]: callable
537 ------> callable()
537 ------> callable()
538
538
539 Note that even with autocall off, you can still use '/' at the start of
539 Note that even with autocall off, you can still use '/' at the start of
540 a line to treat the first argument on the command line as a function
540 a line to treat the first argument on the command line as a function
541 and add parentheses to it:
541 and add parentheses to it:
542
542
543 In [8]: /str 43
543 In [8]: /str 43
544 ------> str(43)
544 ------> str(43)
545 Out[8]: '43'
545 Out[8]: '43'
546 """
546 """
547
547
548 rc = self.shell.rc
548 rc = self.shell.rc
549
549
550 if parameter_s:
550 if parameter_s:
551 arg = int(parameter_s)
551 arg = int(parameter_s)
552 else:
552 else:
553 arg = 'toggle'
553 arg = 'toggle'
554
554
555 if not arg in (0,1,2,'toggle'):
555 if not arg in (0,1,2,'toggle'):
556 error('Valid modes: (0->Off, 1->Smart, 2->Full')
556 error('Valid modes: (0->Off, 1->Smart, 2->Full')
557 return
557 return
558
558
559 if arg in (0,1,2):
559 if arg in (0,1,2):
560 rc.autocall = arg
560 rc.autocall = arg
561 else: # toggle
561 else: # toggle
562 if rc.autocall:
562 if rc.autocall:
563 self._magic_state.autocall_save = rc.autocall
563 self._magic_state.autocall_save = rc.autocall
564 rc.autocall = 0
564 rc.autocall = 0
565 else:
565 else:
566 try:
566 try:
567 rc.autocall = self._magic_state.autocall_save
567 rc.autocall = self._magic_state.autocall_save
568 except AttributeError:
568 except AttributeError:
569 rc.autocall = self._magic_state.autocall_save = 1
569 rc.autocall = self._magic_state.autocall_save = 1
570
570
571 print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
571 print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
572
572
573 def magic_system_verbose(self, parameter_s = ''):
573 def magic_system_verbose(self, parameter_s = ''):
574 """Set verbose printing of system calls.
574 """Set verbose printing of system calls.
575
575
576 If called without an argument, act as a toggle"""
576 If called without an argument, act as a toggle"""
577
577
578 if parameter_s:
578 if parameter_s:
579 val = bool(eval(parameter_s))
579 val = bool(eval(parameter_s))
580 else:
580 else:
581 val = None
581 val = None
582
582
583 self.shell.rc_set_toggle('system_verbose',val)
583 self.shell.rc_set_toggle('system_verbose',val)
584 print "System verbose printing is:",\
584 print "System verbose printing is:",\
585 ['OFF','ON'][self.shell.rc.system_verbose]
585 ['OFF','ON'][self.shell.rc.system_verbose]
586
586
587
587
588 def magic_page(self, parameter_s=''):
588 def magic_page(self, parameter_s=''):
589 """Pretty print the object and display it through a pager.
589 """Pretty print the object and display it through a pager.
590
590
591 %page [options] OBJECT
591 %page [options] OBJECT
592
592
593 If no object is given, use _ (last output).
593 If no object is given, use _ (last output).
594
594
595 Options:
595 Options:
596
596
597 -r: page str(object), don't pretty-print it."""
597 -r: page str(object), don't pretty-print it."""
598
598
599 # After a function contributed by Olivier Aubert, slightly modified.
599 # After a function contributed by Olivier Aubert, slightly modified.
600
600
601 # Process options/args
601 # Process options/args
602 opts,args = self.parse_options(parameter_s,'r')
602 opts,args = self.parse_options(parameter_s,'r')
603 raw = 'r' in opts
603 raw = 'r' in opts
604
604
605 oname = args and args or '_'
605 oname = args and args or '_'
606 info = self._ofind(oname)
606 info = self._ofind(oname)
607 if info['found']:
607 if info['found']:
608 txt = (raw and str or pformat)( info['obj'] )
608 txt = (raw and str or pformat)( info['obj'] )
609 page(txt)
609 page(txt)
610 else:
610 else:
611 print 'Object `%s` not found' % oname
611 print 'Object `%s` not found' % oname
612
612
613 def magic_profile(self, parameter_s=''):
613 def magic_profile(self, parameter_s=''):
614 """Print your currently active IPyhton profile."""
614 """Print your currently active IPyhton profile."""
615 if self.shell.rc.profile:
615 if self.shell.rc.profile:
616 printpl('Current IPython profile: $self.shell.rc.profile.')
616 printpl('Current IPython profile: $self.shell.rc.profile.')
617 else:
617 else:
618 print 'No profile active.'
618 print 'No profile active.'
619
619
620 def magic_pinfo(self, parameter_s='', namespaces=None):
620 def magic_pinfo(self, parameter_s='', namespaces=None):
621 """Provide detailed information about an object.
621 """Provide detailed information about an object.
622
622
623 '%pinfo object' is just a synonym for object? or ?object."""
623 '%pinfo object' is just a synonym for object? or ?object."""
624
624
625 #print 'pinfo par: <%s>' % parameter_s # dbg
625 #print 'pinfo par: <%s>' % parameter_s # dbg
626
626
627
627
628 # detail_level: 0 -> obj? , 1 -> obj??
628 # detail_level: 0 -> obj? , 1 -> obj??
629 detail_level = 0
629 detail_level = 0
630 # We need to detect if we got called as 'pinfo pinfo foo', which can
630 # We need to detect if we got called as 'pinfo pinfo foo', which can
631 # happen if the user types 'pinfo foo?' at the cmd line.
631 # happen if the user types 'pinfo foo?' at the cmd line.
632 pinfo,qmark1,oname,qmark2 = \
632 pinfo,qmark1,oname,qmark2 = \
633 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
633 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
634 if pinfo or qmark1 or qmark2:
634 if pinfo or qmark1 or qmark2:
635 detail_level = 1
635 detail_level = 1
636 if "*" in oname:
636 if "*" in oname:
637 self.magic_psearch(oname)
637 self.magic_psearch(oname)
638 else:
638 else:
639 self._inspect('pinfo', oname, detail_level=detail_level,
639 self._inspect('pinfo', oname, detail_level=detail_level,
640 namespaces=namespaces)
640 namespaces=namespaces)
641
641
642 def magic_pdef(self, parameter_s='', namespaces=None):
642 def magic_pdef(self, parameter_s='', namespaces=None):
643 """Print the definition header for any callable object.
643 """Print the definition header for any callable object.
644
644
645 If the object is a class, print the constructor information."""
645 If the object is a class, print the constructor information."""
646 self._inspect('pdef',parameter_s, namespaces)
646 self._inspect('pdef',parameter_s, namespaces)
647
647
648 def magic_pdoc(self, parameter_s='', namespaces=None):
648 def magic_pdoc(self, parameter_s='', namespaces=None):
649 """Print the docstring for an object.
649 """Print the docstring for an object.
650
650
651 If the given object is a class, it will print both the class and the
651 If the given object is a class, it will print both the class and the
652 constructor docstrings."""
652 constructor docstrings."""
653 self._inspect('pdoc',parameter_s, namespaces)
653 self._inspect('pdoc',parameter_s, namespaces)
654
654
655 def magic_psource(self, parameter_s='', namespaces=None):
655 def magic_psource(self, parameter_s='', namespaces=None):
656 """Print (or run through pager) the source code for an object."""
656 """Print (or run through pager) the source code for an object."""
657 self._inspect('psource',parameter_s, namespaces)
657 self._inspect('psource',parameter_s, namespaces)
658
658
659 def magic_pfile(self, parameter_s=''):
659 def magic_pfile(self, parameter_s=''):
660 """Print (or run through pager) the file where an object is defined.
660 """Print (or run through pager) the file where an object is defined.
661
661
662 The file opens at the line where the object definition begins. IPython
662 The file opens at the line where the object definition begins. IPython
663 will honor the environment variable PAGER if set, and otherwise will
663 will honor the environment variable PAGER if set, and otherwise will
664 do its best to print the file in a convenient form.
664 do its best to print the file in a convenient form.
665
665
666 If the given argument is not an object currently defined, IPython will
666 If the given argument is not an object currently defined, IPython will
667 try to interpret it as a filename (automatically adding a .py extension
667 try to interpret it as a filename (automatically adding a .py extension
668 if needed). You can thus use %pfile as a syntax highlighting code
668 if needed). You can thus use %pfile as a syntax highlighting code
669 viewer."""
669 viewer."""
670
670
671 # first interpret argument as an object name
671 # first interpret argument as an object name
672 out = self._inspect('pfile',parameter_s)
672 out = self._inspect('pfile',parameter_s)
673 # if not, try the input as a filename
673 # if not, try the input as a filename
674 if out == 'not found':
674 if out == 'not found':
675 try:
675 try:
676 filename = get_py_filename(parameter_s)
676 filename = get_py_filename(parameter_s)
677 except IOError,msg:
677 except IOError,msg:
678 print msg
678 print msg
679 return
679 return
680 page(self.shell.inspector.format(file(filename).read()))
680 page(self.shell.inspector.format(file(filename).read()))
681
681
682 def _inspect(self,meth,oname,namespaces=None,**kw):
682 def _inspect(self,meth,oname,namespaces=None,**kw):
683 """Generic interface to the inspector system.
683 """Generic interface to the inspector system.
684
684
685 This function is meant to be called by pdef, pdoc & friends."""
685 This function is meant to be called by pdef, pdoc & friends."""
686
686
687 #oname = oname.strip()
687 #oname = oname.strip()
688 #print '1- oname: <%r>' % oname # dbg
688 #print '1- oname: <%r>' % oname # dbg
689 try:
689 try:
690 oname = oname.strip().encode('ascii')
690 oname = oname.strip().encode('ascii')
691 #print '2- oname: <%r>' % oname # dbg
691 #print '2- oname: <%r>' % oname # dbg
692 except UnicodeEncodeError:
692 except UnicodeEncodeError:
693 print 'Python identifiers can only contain ascii characters.'
693 print 'Python identifiers can only contain ascii characters.'
694 return 'not found'
694 return 'not found'
695
695
696 info = Struct(self._ofind(oname, namespaces))
696 info = Struct(self._ofind(oname, namespaces))
697
697
698 if info.found:
698 if info.found:
699 try:
699 try:
700 IPython.generics.inspect_object(info.obj)
700 IPython.generics.inspect_object(info.obj)
701 return
701 return
702 except IPython.ipapi.TryNext:
702 except IPython.ipapi.TryNext:
703 pass
703 pass
704 # Get the docstring of the class property if it exists.
704 # Get the docstring of the class property if it exists.
705 path = oname.split('.')
705 path = oname.split('.')
706 root = '.'.join(path[:-1])
706 root = '.'.join(path[:-1])
707 if info.parent is not None:
707 if info.parent is not None:
708 try:
708 try:
709 target = getattr(info.parent, '__class__')
709 target = getattr(info.parent, '__class__')
710 # The object belongs to a class instance.
710 # The object belongs to a class instance.
711 try:
711 try:
712 target = getattr(target, path[-1])
712 target = getattr(target, path[-1])
713 # The class defines the object.
713 # The class defines the object.
714 if isinstance(target, property):
714 if isinstance(target, property):
715 oname = root + '.__class__.' + path[-1]
715 oname = root + '.__class__.' + path[-1]
716 info = Struct(self._ofind(oname))
716 info = Struct(self._ofind(oname))
717 except AttributeError: pass
717 except AttributeError: pass
718 except AttributeError: pass
718 except AttributeError: pass
719
719
720 pmethod = getattr(self.shell.inspector,meth)
720 pmethod = getattr(self.shell.inspector,meth)
721 formatter = info.ismagic and self.format_screen or None
721 formatter = info.ismagic and self.format_screen or None
722 if meth == 'pdoc':
722 if meth == 'pdoc':
723 pmethod(info.obj,oname,formatter)
723 pmethod(info.obj,oname,formatter)
724 elif meth == 'pinfo':
724 elif meth == 'pinfo':
725 pmethod(info.obj,oname,formatter,info,**kw)
725 pmethod(info.obj,oname,formatter,info,**kw)
726 else:
726 else:
727 pmethod(info.obj,oname)
727 pmethod(info.obj,oname)
728 else:
728 else:
729 print 'Object `%s` not found.' % oname
729 print 'Object `%s` not found.' % oname
730 return 'not found' # so callers can take other action
730 return 'not found' # so callers can take other action
731
731
732 def magic_psearch(self, parameter_s=''):
732 def magic_psearch(self, parameter_s=''):
733 """Search for object in namespaces by wildcard.
733 """Search for object in namespaces by wildcard.
734
734
735 %psearch [options] PATTERN [OBJECT TYPE]
735 %psearch [options] PATTERN [OBJECT TYPE]
736
736
737 Note: ? can be used as a synonym for %psearch, at the beginning or at
737 Note: ? can be used as a synonym for %psearch, at the beginning or at
738 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
738 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
739 rest of the command line must be unchanged (options come first), so
739 rest of the command line must be unchanged (options come first), so
740 for example the following forms are equivalent
740 for example the following forms are equivalent
741
741
742 %psearch -i a* function
742 %psearch -i a* function
743 -i a* function?
743 -i a* function?
744 ?-i a* function
744 ?-i a* function
745
745
746 Arguments:
746 Arguments:
747
747
748 PATTERN
748 PATTERN
749
749
750 where PATTERN is a string containing * as a wildcard similar to its
750 where PATTERN is a string containing * as a wildcard similar to its
751 use in a shell. The pattern is matched in all namespaces on the
751 use in a shell. The pattern is matched in all namespaces on the
752 search path. By default objects starting with a single _ are not
752 search path. By default objects starting with a single _ are not
753 matched, many IPython generated objects have a single
753 matched, many IPython generated objects have a single
754 underscore. The default is case insensitive matching. Matching is
754 underscore. The default is case insensitive matching. Matching is
755 also done on the attributes of objects and not only on the objects
755 also done on the attributes of objects and not only on the objects
756 in a module.
756 in a module.
757
757
758 [OBJECT TYPE]
758 [OBJECT TYPE]
759
759
760 Is the name of a python type from the types module. The name is
760 Is the name of a python type from the types module. The name is
761 given in lowercase without the ending type, ex. StringType is
761 given in lowercase without the ending type, ex. StringType is
762 written string. By adding a type here only objects matching the
762 written string. By adding a type here only objects matching the
763 given type are matched. Using all here makes the pattern match all
763 given type are matched. Using all here makes the pattern match all
764 types (this is the default).
764 types (this is the default).
765
765
766 Options:
766 Options:
767
767
768 -a: makes the pattern match even objects whose names start with a
768 -a: makes the pattern match even objects whose names start with a
769 single underscore. These names are normally ommitted from the
769 single underscore. These names are normally ommitted from the
770 search.
770 search.
771
771
772 -i/-c: make the pattern case insensitive/sensitive. If neither of
772 -i/-c: make the pattern case insensitive/sensitive. If neither of
773 these options is given, the default is read from your ipythonrc
773 these options is given, the default is read from your ipythonrc
774 file. The option name which sets this value is
774 file. The option name which sets this value is
775 'wildcards_case_sensitive'. If this option is not specified in your
775 'wildcards_case_sensitive'. If this option is not specified in your
776 ipythonrc file, IPython's internal default is to do a case sensitive
776 ipythonrc file, IPython's internal default is to do a case sensitive
777 search.
777 search.
778
778
779 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
779 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
780 specifiy can be searched in any of the following namespaces:
780 specifiy can be searched in any of the following namespaces:
781 'builtin', 'user', 'user_global','internal', 'alias', where
781 'builtin', 'user', 'user_global','internal', 'alias', where
782 'builtin' and 'user' are the search defaults. Note that you should
782 'builtin' and 'user' are the search defaults. Note that you should
783 not use quotes when specifying namespaces.
783 not use quotes when specifying namespaces.
784
784
785 'Builtin' contains the python module builtin, 'user' contains all
785 'Builtin' contains the python module builtin, 'user' contains all
786 user data, 'alias' only contain the shell aliases and no python
786 user data, 'alias' only contain the shell aliases and no python
787 objects, 'internal' contains objects used by IPython. The
787 objects, 'internal' contains objects used by IPython. The
788 'user_global' namespace is only used by embedded IPython instances,
788 'user_global' namespace is only used by embedded IPython instances,
789 and it contains module-level globals. You can add namespaces to the
789 and it contains module-level globals. You can add namespaces to the
790 search with -s or exclude them with -e (these options can be given
790 search with -s or exclude them with -e (these options can be given
791 more than once).
791 more than once).
792
792
793 Examples:
793 Examples:
794
794
795 %psearch a* -> objects beginning with an a
795 %psearch a* -> objects beginning with an a
796 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
796 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
797 %psearch a* function -> all functions beginning with an a
797 %psearch a* function -> all functions beginning with an a
798 %psearch re.e* -> objects beginning with an e in module re
798 %psearch re.e* -> objects beginning with an e in module re
799 %psearch r*.e* -> objects that start with e in modules starting in r
799 %psearch r*.e* -> objects that start with e in modules starting in r
800 %psearch r*.* string -> all strings in modules beginning with r
800 %psearch r*.* string -> all strings in modules beginning with r
801
801
802 Case sensitve search:
802 Case sensitve search:
803
803
804 %psearch -c a* list all object beginning with lower case a
804 %psearch -c a* list all object beginning with lower case a
805
805
806 Show objects beginning with a single _:
806 Show objects beginning with a single _:
807
807
808 %psearch -a _* list objects beginning with a single underscore"""
808 %psearch -a _* list objects beginning with a single underscore"""
809 try:
809 try:
810 parameter_s = parameter_s.encode('ascii')
810 parameter_s = parameter_s.encode('ascii')
811 except UnicodeEncodeError:
811 except UnicodeEncodeError:
812 print 'Python identifiers can only contain ascii characters.'
812 print 'Python identifiers can only contain ascii characters.'
813 return
813 return
814
814
815 # default namespaces to be searched
815 # default namespaces to be searched
816 def_search = ['user','builtin']
816 def_search = ['user','builtin']
817
817
818 # Process options/args
818 # Process options/args
819 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
819 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
820 opt = opts.get
820 opt = opts.get
821 shell = self.shell
821 shell = self.shell
822 psearch = shell.inspector.psearch
822 psearch = shell.inspector.psearch
823
823
824 # select case options
824 # select case options
825 if opts.has_key('i'):
825 if opts.has_key('i'):
826 ignore_case = True
826 ignore_case = True
827 elif opts.has_key('c'):
827 elif opts.has_key('c'):
828 ignore_case = False
828 ignore_case = False
829 else:
829 else:
830 ignore_case = not shell.rc.wildcards_case_sensitive
830 ignore_case = not shell.rc.wildcards_case_sensitive
831
831
832 # Build list of namespaces to search from user options
832 # Build list of namespaces to search from user options
833 def_search.extend(opt('s',[]))
833 def_search.extend(opt('s',[]))
834 ns_exclude = ns_exclude=opt('e',[])
834 ns_exclude = ns_exclude=opt('e',[])
835 ns_search = [nm for nm in def_search if nm not in ns_exclude]
835 ns_search = [nm for nm in def_search if nm not in ns_exclude]
836
836
837 # Call the actual search
837 # Call the actual search
838 try:
838 try:
839 psearch(args,shell.ns_table,ns_search,
839 psearch(args,shell.ns_table,ns_search,
840 show_all=opt('a'),ignore_case=ignore_case)
840 show_all=opt('a'),ignore_case=ignore_case)
841 except:
841 except:
842 shell.showtraceback()
842 shell.showtraceback()
843
843
844 def magic_who_ls(self, parameter_s=''):
844 def magic_who_ls(self, parameter_s=''):
845 """Return a sorted list of all interactive variables.
845 """Return a sorted list of all interactive variables.
846
846
847 If arguments are given, only variables of types matching these
847 If arguments are given, only variables of types matching these
848 arguments are returned."""
848 arguments are returned."""
849
849
850 user_ns = self.shell.user_ns
850 user_ns = self.shell.user_ns
851 internal_ns = self.shell.internal_ns
851 internal_ns = self.shell.internal_ns
852 user_config_ns = self.shell.user_config_ns
852 user_config_ns = self.shell.user_config_ns
853 out = []
853 out = []
854 typelist = parameter_s.split()
854 typelist = parameter_s.split()
855
855
856 for i in user_ns:
856 for i in user_ns:
857 if not (i.startswith('_') or i.startswith('_i')) \
857 if not (i.startswith('_') or i.startswith('_i')) \
858 and not (i in internal_ns or i in user_config_ns):
858 and not (i in internal_ns or i in user_config_ns):
859 if typelist:
859 if typelist:
860 if type(user_ns[i]).__name__ in typelist:
860 if type(user_ns[i]).__name__ in typelist:
861 out.append(i)
861 out.append(i)
862 else:
862 else:
863 out.append(i)
863 out.append(i)
864 out.sort()
864 out.sort()
865 return out
865 return out
866
866
867 def magic_who(self, parameter_s=''):
867 def magic_who(self, parameter_s=''):
868 """Print all interactive variables, with some minimal formatting.
868 """Print all interactive variables, with some minimal formatting.
869
869
870 If any arguments are given, only variables whose type matches one of
870 If any arguments are given, only variables whose type matches one of
871 these are printed. For example:
871 these are printed. For example:
872
872
873 %who function str
873 %who function str
874
874
875 will only list functions and strings, excluding all other types of
875 will only list functions and strings, excluding all other types of
876 variables. To find the proper type names, simply use type(var) at a
876 variables. To find the proper type names, simply use type(var) at a
877 command line to see how python prints type names. For example:
877 command line to see how python prints type names. For example:
878
878
879 In [1]: type('hello')\\
879 In [1]: type('hello')\\
880 Out[1]: <type 'str'>
880 Out[1]: <type 'str'>
881
881
882 indicates that the type name for strings is 'str'.
882 indicates that the type name for strings is 'str'.
883
883
884 %who always excludes executed names loaded through your configuration
884 %who always excludes executed names loaded through your configuration
885 file and things which are internal to IPython.
885 file and things which are internal to IPython.
886
886
887 This is deliberate, as typically you may load many modules and the
887 This is deliberate, as typically you may load many modules and the
888 purpose of %who is to show you only what you've manually defined."""
888 purpose of %who is to show you only what you've manually defined."""
889
889
890 varlist = self.magic_who_ls(parameter_s)
890 varlist = self.magic_who_ls(parameter_s)
891 if not varlist:
891 if not varlist:
892 if parameter_s:
892 if parameter_s:
893 print 'No variables match your requested type.'
893 print 'No variables match your requested type.'
894 else:
894 else:
895 print 'Interactive namespace is empty.'
895 print 'Interactive namespace is empty.'
896 return
896 return
897
897
898 # if we have variables, move on...
898 # if we have variables, move on...
899 count = 0
899 count = 0
900 for i in varlist:
900 for i in varlist:
901 print i+'\t',
901 print i+'\t',
902 count += 1
902 count += 1
903 if count > 8:
903 if count > 8:
904 count = 0
904 count = 0
905 print
905 print
906 print
906 print
907
907
908 def magic_whos(self, parameter_s=''):
908 def magic_whos(self, parameter_s=''):
909 """Like %who, but gives some extra information about each variable.
909 """Like %who, but gives some extra information about each variable.
910
910
911 The same type filtering of %who can be applied here.
911 The same type filtering of %who can be applied here.
912
912
913 For all variables, the type is printed. Additionally it prints:
913 For all variables, the type is printed. Additionally it prints:
914
914
915 - For {},[],(): their length.
915 - For {},[],(): their length.
916
916
917 - For numpy and Numeric arrays, a summary with shape, number of
917 - For numpy and Numeric arrays, a summary with shape, number of
918 elements, typecode and size in memory.
918 elements, typecode and size in memory.
919
919
920 - Everything else: a string representation, snipping their middle if
920 - Everything else: a string representation, snipping their middle if
921 too long."""
921 too long."""
922
922
923 varnames = self.magic_who_ls(parameter_s)
923 varnames = self.magic_who_ls(parameter_s)
924 if not varnames:
924 if not varnames:
925 if parameter_s:
925 if parameter_s:
926 print 'No variables match your requested type.'
926 print 'No variables match your requested type.'
927 else:
927 else:
928 print 'Interactive namespace is empty.'
928 print 'Interactive namespace is empty.'
929 return
929 return
930
930
931 # if we have variables, move on...
931 # if we have variables, move on...
932
932
933 # for these types, show len() instead of data:
933 # for these types, show len() instead of data:
934 seq_types = [types.DictType,types.ListType,types.TupleType]
934 seq_types = [types.DictType,types.ListType,types.TupleType]
935
935
936 # for numpy/Numeric arrays, display summary info
936 # for numpy/Numeric arrays, display summary info
937 try:
937 try:
938 import numpy
938 import numpy
939 except ImportError:
939 except ImportError:
940 ndarray_type = None
940 ndarray_type = None
941 else:
941 else:
942 ndarray_type = numpy.ndarray.__name__
942 ndarray_type = numpy.ndarray.__name__
943 try:
943 try:
944 import Numeric
944 import Numeric
945 except ImportError:
945 except ImportError:
946 array_type = None
946 array_type = None
947 else:
947 else:
948 array_type = Numeric.ArrayType.__name__
948 array_type = Numeric.ArrayType.__name__
949
949
950 # Find all variable names and types so we can figure out column sizes
950 # Find all variable names and types so we can figure out column sizes
951 def get_vars(i):
951 def get_vars(i):
952 return self.shell.user_ns[i]
952 return self.shell.user_ns[i]
953
953
954 # some types are well known and can be shorter
954 # some types are well known and can be shorter
955 abbrevs = {'IPython.macro.Macro' : 'Macro'}
955 abbrevs = {'IPython.macro.Macro' : 'Macro'}
956 def type_name(v):
956 def type_name(v):
957 tn = type(v).__name__
957 tn = type(v).__name__
958 return abbrevs.get(tn,tn)
958 return abbrevs.get(tn,tn)
959
959
960 varlist = map(get_vars,varnames)
960 varlist = map(get_vars,varnames)
961
961
962 typelist = []
962 typelist = []
963 for vv in varlist:
963 for vv in varlist:
964 tt = type_name(vv)
964 tt = type_name(vv)
965
965
966 if tt=='instance':
966 if tt=='instance':
967 typelist.append( abbrevs.get(str(vv.__class__),
967 typelist.append( abbrevs.get(str(vv.__class__),
968 str(vv.__class__)))
968 str(vv.__class__)))
969 else:
969 else:
970 typelist.append(tt)
970 typelist.append(tt)
971
971
972 # column labels and # of spaces as separator
972 # column labels and # of spaces as separator
973 varlabel = 'Variable'
973 varlabel = 'Variable'
974 typelabel = 'Type'
974 typelabel = 'Type'
975 datalabel = 'Data/Info'
975 datalabel = 'Data/Info'
976 colsep = 3
976 colsep = 3
977 # variable format strings
977 # variable format strings
978 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
978 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
979 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
979 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
980 aformat = "%s: %s elems, type `%s`, %s bytes"
980 aformat = "%s: %s elems, type `%s`, %s bytes"
981 # find the size of the columns to format the output nicely
981 # find the size of the columns to format the output nicely
982 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
982 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
983 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
983 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
984 # table header
984 # table header
985 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
985 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
986 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
986 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
987 # and the table itself
987 # and the table itself
988 kb = 1024
988 kb = 1024
989 Mb = 1048576 # kb**2
989 Mb = 1048576 # kb**2
990 for vname,var,vtype in zip(varnames,varlist,typelist):
990 for vname,var,vtype in zip(varnames,varlist,typelist):
991 print itpl(vformat),
991 print itpl(vformat),
992 if vtype in seq_types:
992 if vtype in seq_types:
993 print len(var)
993 print len(var)
994 elif vtype in [array_type,ndarray_type]:
994 elif vtype in [array_type,ndarray_type]:
995 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
995 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
996 if vtype==ndarray_type:
996 if vtype==ndarray_type:
997 # numpy
997 # numpy
998 vsize = var.size
998 vsize = var.size
999 vbytes = vsize*var.itemsize
999 vbytes = vsize*var.itemsize
1000 vdtype = var.dtype
1000 vdtype = var.dtype
1001 else:
1001 else:
1002 # Numeric
1002 # Numeric
1003 vsize = Numeric.size(var)
1003 vsize = Numeric.size(var)
1004 vbytes = vsize*var.itemsize()
1004 vbytes = vsize*var.itemsize()
1005 vdtype = var.typecode()
1005 vdtype = var.typecode()
1006
1006
1007 if vbytes < 100000:
1007 if vbytes < 100000:
1008 print aformat % (vshape,vsize,vdtype,vbytes)
1008 print aformat % (vshape,vsize,vdtype,vbytes)
1009 else:
1009 else:
1010 print aformat % (vshape,vsize,vdtype,vbytes),
1010 print aformat % (vshape,vsize,vdtype,vbytes),
1011 if vbytes < Mb:
1011 if vbytes < Mb:
1012 print '(%s kb)' % (vbytes/kb,)
1012 print '(%s kb)' % (vbytes/kb,)
1013 else:
1013 else:
1014 print '(%s Mb)' % (vbytes/Mb,)
1014 print '(%s Mb)' % (vbytes/Mb,)
1015 else:
1015 else:
1016 try:
1016 try:
1017 vstr = str(var)
1017 vstr = str(var)
1018 except UnicodeEncodeError:
1018 except UnicodeEncodeError:
1019 vstr = unicode(var).encode(sys.getdefaultencoding(),
1019 vstr = unicode(var).encode(sys.getdefaultencoding(),
1020 'backslashreplace')
1020 'backslashreplace')
1021 vstr = vstr.replace('\n','\\n')
1021 vstr = vstr.replace('\n','\\n')
1022 if len(vstr) < 50:
1022 if len(vstr) < 50:
1023 print vstr
1023 print vstr
1024 else:
1024 else:
1025 printpl(vfmt_short)
1025 printpl(vfmt_short)
1026
1026
1027 def magic_reset(self, parameter_s=''):
1027 def magic_reset(self, parameter_s=''):
1028 """Resets the namespace by removing all names defined by the user.
1028 """Resets the namespace by removing all names defined by the user.
1029
1029
1030 Input/Output history are left around in case you need them."""
1030 Input/Output history are left around in case you need them."""
1031
1031
1032 ans = self.shell.ask_yes_no(
1032 ans = self.shell.ask_yes_no(
1033 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
1033 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
1034 if not ans:
1034 if not ans:
1035 print 'Nothing done.'
1035 print 'Nothing done.'
1036 return
1036 return
1037 user_ns = self.shell.user_ns
1037 user_ns = self.shell.user_ns
1038 for i in self.magic_who_ls():
1038 for i in self.magic_who_ls():
1039 del(user_ns[i])
1039 del(user_ns[i])
1040
1040
1041 # Also flush the private list of module references kept for script
1041 # Also flush the private list of module references kept for script
1042 # execution protection
1042 # execution protection
1043 self.shell._user_main_modules[:] = []
1043 self.shell._user_main_modules[:] = []
1044
1044
1045 def magic_logstart(self,parameter_s=''):
1045 def magic_logstart(self,parameter_s=''):
1046 """Start logging anywhere in a session.
1046 """Start logging anywhere in a session.
1047
1047
1048 %logstart [-o|-r|-t] [log_name [log_mode]]
1048 %logstart [-o|-r|-t] [log_name [log_mode]]
1049
1049
1050 If no name is given, it defaults to a file named 'ipython_log.py' in your
1050 If no name is given, it defaults to a file named 'ipython_log.py' in your
1051 current directory, in 'rotate' mode (see below).
1051 current directory, in 'rotate' mode (see below).
1052
1052
1053 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1053 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1054 history up to that point and then continues logging.
1054 history up to that point and then continues logging.
1055
1055
1056 %logstart takes a second optional parameter: logging mode. This can be one
1056 %logstart takes a second optional parameter: logging mode. This can be one
1057 of (note that the modes are given unquoted):\\
1057 of (note that the modes are given unquoted):\\
1058 append: well, that says it.\\
1058 append: well, that says it.\\
1059 backup: rename (if exists) to name~ and start name.\\
1059 backup: rename (if exists) to name~ and start name.\\
1060 global: single logfile in your home dir, appended to.\\
1060 global: single logfile in your home dir, appended to.\\
1061 over : overwrite existing log.\\
1061 over : overwrite existing log.\\
1062 rotate: create rotating logs name.1~, name.2~, etc.
1062 rotate: create rotating logs name.1~, name.2~, etc.
1063
1063
1064 Options:
1064 Options:
1065
1065
1066 -o: log also IPython's output. In this mode, all commands which
1066 -o: log also IPython's output. In this mode, all commands which
1067 generate an Out[NN] prompt are recorded to the logfile, right after
1067 generate an Out[NN] prompt are recorded to the logfile, right after
1068 their corresponding input line. The output lines are always
1068 their corresponding input line. The output lines are always
1069 prepended with a '#[Out]# ' marker, so that the log remains valid
1069 prepended with a '#[Out]# ' marker, so that the log remains valid
1070 Python code.
1070 Python code.
1071
1071
1072 Since this marker is always the same, filtering only the output from
1072 Since this marker is always the same, filtering only the output from
1073 a log is very easy, using for example a simple awk call:
1073 a log is very easy, using for example a simple awk call:
1074
1074
1075 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1075 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1076
1076
1077 -r: log 'raw' input. Normally, IPython's logs contain the processed
1077 -r: log 'raw' input. Normally, IPython's logs contain the processed
1078 input, so that user lines are logged in their final form, converted
1078 input, so that user lines are logged in their final form, converted
1079 into valid Python. For example, %Exit is logged as
1079 into valid Python. For example, %Exit is logged as
1080 '_ip.magic("Exit"). If the -r flag is given, all input is logged
1080 '_ip.magic("Exit"). If the -r flag is given, all input is logged
1081 exactly as typed, with no transformations applied.
1081 exactly as typed, with no transformations applied.
1082
1082
1083 -t: put timestamps before each input line logged (these are put in
1083 -t: put timestamps before each input line logged (these are put in
1084 comments)."""
1084 comments)."""
1085
1085
1086 opts,par = self.parse_options(parameter_s,'ort')
1086 opts,par = self.parse_options(parameter_s,'ort')
1087 log_output = 'o' in opts
1087 log_output = 'o' in opts
1088 log_raw_input = 'r' in opts
1088 log_raw_input = 'r' in opts
1089 timestamp = 't' in opts
1089 timestamp = 't' in opts
1090
1090
1091 rc = self.shell.rc
1091 rc = self.shell.rc
1092 logger = self.shell.logger
1092 logger = self.shell.logger
1093
1093
1094 # if no args are given, the defaults set in the logger constructor by
1094 # if no args are given, the defaults set in the logger constructor by
1095 # ipytohn remain valid
1095 # ipytohn remain valid
1096 if par:
1096 if par:
1097 try:
1097 try:
1098 logfname,logmode = par.split()
1098 logfname,logmode = par.split()
1099 except:
1099 except:
1100 logfname = par
1100 logfname = par
1101 logmode = 'backup'
1101 logmode = 'backup'
1102 else:
1102 else:
1103 logfname = logger.logfname
1103 logfname = logger.logfname
1104 logmode = logger.logmode
1104 logmode = logger.logmode
1105 # put logfname into rc struct as if it had been called on the command
1105 # put logfname into rc struct as if it had been called on the command
1106 # line, so it ends up saved in the log header Save it in case we need
1106 # line, so it ends up saved in the log header Save it in case we need
1107 # to restore it...
1107 # to restore it...
1108 old_logfile = rc.opts.get('logfile','')
1108 old_logfile = rc.opts.get('logfile','')
1109 if logfname:
1109 if logfname:
1110 logfname = os.path.expanduser(logfname)
1110 logfname = os.path.expanduser(logfname)
1111 rc.opts.logfile = logfname
1111 rc.opts.logfile = logfname
1112 loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
1112 loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
1113 try:
1113 try:
1114 started = logger.logstart(logfname,loghead,logmode,
1114 started = logger.logstart(logfname,loghead,logmode,
1115 log_output,timestamp,log_raw_input)
1115 log_output,timestamp,log_raw_input)
1116 except:
1116 except:
1117 rc.opts.logfile = old_logfile
1117 rc.opts.logfile = old_logfile
1118 warn("Couldn't start log: %s" % sys.exc_info()[1])
1118 warn("Couldn't start log: %s" % sys.exc_info()[1])
1119 else:
1119 else:
1120 # log input history up to this point, optionally interleaving
1120 # log input history up to this point, optionally interleaving
1121 # output if requested
1121 # output if requested
1122
1122
1123 if timestamp:
1123 if timestamp:
1124 # disable timestamping for the previous history, since we've
1124 # disable timestamping for the previous history, since we've
1125 # lost those already (no time machine here).
1125 # lost those already (no time machine here).
1126 logger.timestamp = False
1126 logger.timestamp = False
1127
1127
1128 if log_raw_input:
1128 if log_raw_input:
1129 input_hist = self.shell.input_hist_raw
1129 input_hist = self.shell.input_hist_raw
1130 else:
1130 else:
1131 input_hist = self.shell.input_hist
1131 input_hist = self.shell.input_hist
1132
1132
1133 if log_output:
1133 if log_output:
1134 log_write = logger.log_write
1134 log_write = logger.log_write
1135 output_hist = self.shell.output_hist
1135 output_hist = self.shell.output_hist
1136 for n in range(1,len(input_hist)-1):
1136 for n in range(1,len(input_hist)-1):
1137 log_write(input_hist[n].rstrip())
1137 log_write(input_hist[n].rstrip())
1138 if n in output_hist:
1138 if n in output_hist:
1139 log_write(repr(output_hist[n]),'output')
1139 log_write(repr(output_hist[n]),'output')
1140 else:
1140 else:
1141 logger.log_write(input_hist[1:])
1141 logger.log_write(input_hist[1:])
1142 if timestamp:
1142 if timestamp:
1143 # re-enable timestamping
1143 # re-enable timestamping
1144 logger.timestamp = True
1144 logger.timestamp = True
1145
1145
1146 print ('Activating auto-logging. '
1146 print ('Activating auto-logging. '
1147 'Current session state plus future input saved.')
1147 'Current session state plus future input saved.')
1148 logger.logstate()
1148 logger.logstate()
1149
1149
1150 def magic_logstop(self,parameter_s=''):
1150 def magic_logstop(self,parameter_s=''):
1151 """Fully stop logging and close log file.
1151 """Fully stop logging and close log file.
1152
1152
1153 In order to start logging again, a new %logstart call needs to be made,
1153 In order to start logging again, a new %logstart call needs to be made,
1154 possibly (though not necessarily) with a new filename, mode and other
1154 possibly (though not necessarily) with a new filename, mode and other
1155 options."""
1155 options."""
1156 self.logger.logstop()
1156 self.logger.logstop()
1157
1157
1158 def magic_logoff(self,parameter_s=''):
1158 def magic_logoff(self,parameter_s=''):
1159 """Temporarily stop logging.
1159 """Temporarily stop logging.
1160
1160
1161 You must have previously started logging."""
1161 You must have previously started logging."""
1162 self.shell.logger.switch_log(0)
1162 self.shell.logger.switch_log(0)
1163
1163
1164 def magic_logon(self,parameter_s=''):
1164 def magic_logon(self,parameter_s=''):
1165 """Restart logging.
1165 """Restart logging.
1166
1166
1167 This function is for restarting logging which you've temporarily
1167 This function is for restarting logging which you've temporarily
1168 stopped with %logoff. For starting logging for the first time, you
1168 stopped with %logoff. For starting logging for the first time, you
1169 must use the %logstart function, which allows you to specify an
1169 must use the %logstart function, which allows you to specify an
1170 optional log filename."""
1170 optional log filename."""
1171
1171
1172 self.shell.logger.switch_log(1)
1172 self.shell.logger.switch_log(1)
1173
1173
1174 def magic_logstate(self,parameter_s=''):
1174 def magic_logstate(self,parameter_s=''):
1175 """Print the status of the logging system."""
1175 """Print the status of the logging system."""
1176
1176
1177 self.shell.logger.logstate()
1177 self.shell.logger.logstate()
1178
1178
1179 def magic_pdb(self, parameter_s=''):
1179 def magic_pdb(self, parameter_s=''):
1180 """Control the automatic calling of the pdb interactive debugger.
1180 """Control the automatic calling of the pdb interactive debugger.
1181
1181
1182 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1182 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1183 argument it works as a toggle.
1183 argument it works as a toggle.
1184
1184
1185 When an exception is triggered, IPython can optionally call the
1185 When an exception is triggered, IPython can optionally call the
1186 interactive pdb debugger after the traceback printout. %pdb toggles
1186 interactive pdb debugger after the traceback printout. %pdb toggles
1187 this feature on and off.
1187 this feature on and off.
1188
1188
1189 The initial state of this feature is set in your ipythonrc
1189 The initial state of this feature is set in your ipythonrc
1190 configuration file (the variable is called 'pdb').
1190 configuration file (the variable is called 'pdb').
1191
1191
1192 If you want to just activate the debugger AFTER an exception has fired,
1192 If you want to just activate the debugger AFTER an exception has fired,
1193 without having to type '%pdb on' and rerunning your code, you can use
1193 without having to type '%pdb on' and rerunning your code, you can use
1194 the %debug magic."""
1194 the %debug magic."""
1195
1195
1196 par = parameter_s.strip().lower()
1196 par = parameter_s.strip().lower()
1197
1197
1198 if par:
1198 if par:
1199 try:
1199 try:
1200 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1200 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1201 except KeyError:
1201 except KeyError:
1202 print ('Incorrect argument. Use on/1, off/0, '
1202 print ('Incorrect argument. Use on/1, off/0, '
1203 'or nothing for a toggle.')
1203 'or nothing for a toggle.')
1204 return
1204 return
1205 else:
1205 else:
1206 # toggle
1206 # toggle
1207 new_pdb = not self.shell.call_pdb
1207 new_pdb = not self.shell.call_pdb
1208
1208
1209 # set on the shell
1209 # set on the shell
1210 self.shell.call_pdb = new_pdb
1210 self.shell.call_pdb = new_pdb
1211 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1211 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1212
1212
1213 def magic_debug(self, parameter_s=''):
1213 def magic_debug(self, parameter_s=''):
1214 """Activate the interactive debugger in post-mortem mode.
1214 """Activate the interactive debugger in post-mortem mode.
1215
1215
1216 If an exception has just occurred, this lets you inspect its stack
1216 If an exception has just occurred, this lets you inspect its stack
1217 frames interactively. Note that this will always work only on the last
1217 frames interactively. Note that this will always work only on the last
1218 traceback that occurred, so you must call this quickly after an
1218 traceback that occurred, so you must call this quickly after an
1219 exception that you wish to inspect has fired, because if another one
1219 exception that you wish to inspect has fired, because if another one
1220 occurs, it clobbers the previous one.
1220 occurs, it clobbers the previous one.
1221
1221
1222 If you want IPython to automatically do this on every exception, see
1222 If you want IPython to automatically do this on every exception, see
1223 the %pdb magic for more details.
1223 the %pdb magic for more details.
1224 """
1224 """
1225
1225
1226 self.shell.debugger(force=True)
1226 self.shell.debugger(force=True)
1227
1227
1228 def magic_prun(self, parameter_s ='',user_mode=1,
1228 def magic_prun(self, parameter_s ='',user_mode=1,
1229 opts=None,arg_lst=None,prog_ns=None):
1229 opts=None,arg_lst=None,prog_ns=None):
1230
1230
1231 """Run a statement through the python code profiler.
1231 """Run a statement through the python code profiler.
1232
1232
1233 Usage:\\
1233 Usage:\\
1234 %prun [options] statement
1234 %prun [options] statement
1235
1235
1236 The given statement (which doesn't require quote marks) is run via the
1236 The given statement (which doesn't require quote marks) is run via the
1237 python profiler in a manner similar to the profile.run() function.
1237 python profiler in a manner similar to the profile.run() function.
1238 Namespaces are internally managed to work correctly; profile.run
1238 Namespaces are internally managed to work correctly; profile.run
1239 cannot be used in IPython because it makes certain assumptions about
1239 cannot be used in IPython because it makes certain assumptions about
1240 namespaces which do not hold under IPython.
1240 namespaces which do not hold under IPython.
1241
1241
1242 Options:
1242 Options:
1243
1243
1244 -l <limit>: you can place restrictions on what or how much of the
1244 -l <limit>: you can place restrictions on what or how much of the
1245 profile gets printed. The limit value can be:
1245 profile gets printed. The limit value can be:
1246
1246
1247 * A string: only information for function names containing this string
1247 * A string: only information for function names containing this string
1248 is printed.
1248 is printed.
1249
1249
1250 * An integer: only these many lines are printed.
1250 * An integer: only these many lines are printed.
1251
1251
1252 * A float (between 0 and 1): this fraction of the report is printed
1252 * A float (between 0 and 1): this fraction of the report is printed
1253 (for example, use a limit of 0.4 to see the topmost 40% only).
1253 (for example, use a limit of 0.4 to see the topmost 40% only).
1254
1254
1255 You can combine several limits with repeated use of the option. For
1255 You can combine several limits with repeated use of the option. For
1256 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1256 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1257 information about class constructors.
1257 information about class constructors.
1258
1258
1259 -r: return the pstats.Stats object generated by the profiling. This
1259 -r: return the pstats.Stats object generated by the profiling. This
1260 object has all the information about the profile in it, and you can
1260 object has all the information about the profile in it, and you can
1261 later use it for further analysis or in other functions.
1261 later use it for further analysis or in other functions.
1262
1262
1263 -s <key>: sort profile by given key. You can provide more than one key
1263 -s <key>: sort profile by given key. You can provide more than one key
1264 by using the option several times: '-s key1 -s key2 -s key3...'. The
1264 by using the option several times: '-s key1 -s key2 -s key3...'. The
1265 default sorting key is 'time'.
1265 default sorting key is 'time'.
1266
1266
1267 The following is copied verbatim from the profile documentation
1267 The following is copied verbatim from the profile documentation
1268 referenced below:
1268 referenced below:
1269
1269
1270 When more than one key is provided, additional keys are used as
1270 When more than one key is provided, additional keys are used as
1271 secondary criteria when the there is equality in all keys selected
1271 secondary criteria when the there is equality in all keys selected
1272 before them.
1272 before them.
1273
1273
1274 Abbreviations can be used for any key names, as long as the
1274 Abbreviations can be used for any key names, as long as the
1275 abbreviation is unambiguous. The following are the keys currently
1275 abbreviation is unambiguous. The following are the keys currently
1276 defined:
1276 defined:
1277
1277
1278 Valid Arg Meaning\\
1278 Valid Arg Meaning\\
1279 "calls" call count\\
1279 "calls" call count\\
1280 "cumulative" cumulative time\\
1280 "cumulative" cumulative time\\
1281 "file" file name\\
1281 "file" file name\\
1282 "module" file name\\
1282 "module" file name\\
1283 "pcalls" primitive call count\\
1283 "pcalls" primitive call count\\
1284 "line" line number\\
1284 "line" line number\\
1285 "name" function name\\
1285 "name" function name\\
1286 "nfl" name/file/line\\
1286 "nfl" name/file/line\\
1287 "stdname" standard name\\
1287 "stdname" standard name\\
1288 "time" internal time
1288 "time" internal time
1289
1289
1290 Note that all sorts on statistics are in descending order (placing
1290 Note that all sorts on statistics are in descending order (placing
1291 most time consuming items first), where as name, file, and line number
1291 most time consuming items first), where as name, file, and line number
1292 searches are in ascending order (i.e., alphabetical). The subtle
1292 searches are in ascending order (i.e., alphabetical). The subtle
1293 distinction between "nfl" and "stdname" is that the standard name is a
1293 distinction between "nfl" and "stdname" is that the standard name is a
1294 sort of the name as printed, which means that the embedded line
1294 sort of the name as printed, which means that the embedded line
1295 numbers get compared in an odd way. For example, lines 3, 20, and 40
1295 numbers get compared in an odd way. For example, lines 3, 20, and 40
1296 would (if the file names were the same) appear in the string order
1296 would (if the file names were the same) appear in the string order
1297 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1297 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1298 line numbers. In fact, sort_stats("nfl") is the same as
1298 line numbers. In fact, sort_stats("nfl") is the same as
1299 sort_stats("name", "file", "line").
1299 sort_stats("name", "file", "line").
1300
1300
1301 -T <filename>: save profile results as shown on screen to a text
1301 -T <filename>: save profile results as shown on screen to a text
1302 file. The profile is still shown on screen.
1302 file. The profile is still shown on screen.
1303
1303
1304 -D <filename>: save (via dump_stats) profile statistics to given
1304 -D <filename>: save (via dump_stats) profile statistics to given
1305 filename. This data is in a format understod by the pstats module, and
1305 filename. This data is in a format understod by the pstats module, and
1306 is generated by a call to the dump_stats() method of profile
1306 is generated by a call to the dump_stats() method of profile
1307 objects. The profile is still shown on screen.
1307 objects. The profile is still shown on screen.
1308
1308
1309 If you want to run complete programs under the profiler's control, use
1309 If you want to run complete programs under the profiler's control, use
1310 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1310 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1311 contains profiler specific options as described here.
1311 contains profiler specific options as described here.
1312
1312
1313 You can read the complete documentation for the profile module with:\\
1313 You can read the complete documentation for the profile module with:\\
1314 In [1]: import profile; profile.help() """
1314 In [1]: import profile; profile.help() """
1315
1315
1316 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1316 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1317 # protect user quote marks
1317 # protect user quote marks
1318 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1318 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1319
1319
1320 if user_mode: # regular user call
1320 if user_mode: # regular user call
1321 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1321 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1322 list_all=1)
1322 list_all=1)
1323 namespace = self.shell.user_ns
1323 namespace = self.shell.user_ns
1324 else: # called to run a program by %run -p
1324 else: # called to run a program by %run -p
1325 try:
1325 try:
1326 filename = get_py_filename(arg_lst[0])
1326 filename = get_py_filename(arg_lst[0])
1327 except IOError,msg:
1327 except IOError,msg:
1328 error(msg)
1328 error(msg)
1329 return
1329 return
1330
1330
1331 arg_str = 'execfile(filename,prog_ns)'
1331 arg_str = 'execfile(filename,prog_ns)'
1332 namespace = locals()
1332 namespace = locals()
1333
1333
1334 opts.merge(opts_def)
1334 opts.merge(opts_def)
1335
1335
1336 prof = profile.Profile()
1336 prof = profile.Profile()
1337 try:
1337 try:
1338 prof = prof.runctx(arg_str,namespace,namespace)
1338 prof = prof.runctx(arg_str,namespace,namespace)
1339 sys_exit = ''
1339 sys_exit = ''
1340 except SystemExit:
1340 except SystemExit:
1341 sys_exit = """*** SystemExit exception caught in code being profiled."""
1341 sys_exit = """*** SystemExit exception caught in code being profiled."""
1342
1342
1343 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1343 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1344
1344
1345 lims = opts.l
1345 lims = opts.l
1346 if lims:
1346 if lims:
1347 lims = [] # rebuild lims with ints/floats/strings
1347 lims = [] # rebuild lims with ints/floats/strings
1348 for lim in opts.l:
1348 for lim in opts.l:
1349 try:
1349 try:
1350 lims.append(int(lim))
1350 lims.append(int(lim))
1351 except ValueError:
1351 except ValueError:
1352 try:
1352 try:
1353 lims.append(float(lim))
1353 lims.append(float(lim))
1354 except ValueError:
1354 except ValueError:
1355 lims.append(lim)
1355 lims.append(lim)
1356
1356
1357 # Trap output.
1357 # Trap output.
1358 stdout_trap = StringIO()
1358 stdout_trap = StringIO()
1359
1359
1360 if hasattr(stats,'stream'):
1360 if hasattr(stats,'stream'):
1361 # In newer versions of python, the stats object has a 'stream'
1361 # In newer versions of python, the stats object has a 'stream'
1362 # attribute to write into.
1362 # attribute to write into.
1363 stats.stream = stdout_trap
1363 stats.stream = stdout_trap
1364 stats.print_stats(*lims)
1364 stats.print_stats(*lims)
1365 else:
1365 else:
1366 # For older versions, we manually redirect stdout during printing
1366 # For older versions, we manually redirect stdout during printing
1367 sys_stdout = sys.stdout
1367 sys_stdout = sys.stdout
1368 try:
1368 try:
1369 sys.stdout = stdout_trap
1369 sys.stdout = stdout_trap
1370 stats.print_stats(*lims)
1370 stats.print_stats(*lims)
1371 finally:
1371 finally:
1372 sys.stdout = sys_stdout
1372 sys.stdout = sys_stdout
1373
1373
1374 output = stdout_trap.getvalue()
1374 output = stdout_trap.getvalue()
1375 output = output.rstrip()
1375 output = output.rstrip()
1376
1376
1377 page(output,screen_lines=self.shell.rc.screen_length)
1377 page(output,screen_lines=self.shell.rc.screen_length)
1378 print sys_exit,
1378 print sys_exit,
1379
1379
1380 dump_file = opts.D[0]
1380 dump_file = opts.D[0]
1381 text_file = opts.T[0]
1381 text_file = opts.T[0]
1382 if dump_file:
1382 if dump_file:
1383 prof.dump_stats(dump_file)
1383 prof.dump_stats(dump_file)
1384 print '\n*** Profile stats marshalled to file',\
1384 print '\n*** Profile stats marshalled to file',\
1385 `dump_file`+'.',sys_exit
1385 `dump_file`+'.',sys_exit
1386 if text_file:
1386 if text_file:
1387 pfile = file(text_file,'w')
1387 pfile = file(text_file,'w')
1388 pfile.write(output)
1388 pfile.write(output)
1389 pfile.close()
1389 pfile.close()
1390 print '\n*** Profile printout saved to text file',\
1390 print '\n*** Profile printout saved to text file',\
1391 `text_file`+'.',sys_exit
1391 `text_file`+'.',sys_exit
1392
1392
1393 if opts.has_key('r'):
1393 if opts.has_key('r'):
1394 return stats
1394 return stats
1395 else:
1395 else:
1396 return None
1396 return None
1397
1397
1398 def magic_run(self, parameter_s ='',runner=None):
1398 def magic_run(self, parameter_s ='',runner=None):
1399 """Run the named file inside IPython as a program.
1399 """Run the named file inside IPython as a program.
1400
1400
1401 Usage:\\
1401 Usage:\\
1402 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1402 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1403
1403
1404 Parameters after the filename are passed as command-line arguments to
1404 Parameters after the filename are passed as command-line arguments to
1405 the program (put in sys.argv). Then, control returns to IPython's
1405 the program (put in sys.argv). Then, control returns to IPython's
1406 prompt.
1406 prompt.
1407
1407
1408 This is similar to running at a system prompt:\\
1408 This is similar to running at a system prompt:\\
1409 $ python file args\\
1409 $ python file args\\
1410 but with the advantage of giving you IPython's tracebacks, and of
1410 but with the advantage of giving you IPython's tracebacks, and of
1411 loading all variables into your interactive namespace for further use
1411 loading all variables into your interactive namespace for further use
1412 (unless -p is used, see below).
1412 (unless -p is used, see below).
1413
1413
1414 The file is executed in a namespace initially consisting only of
1414 The file is executed in a namespace initially consisting only of
1415 __name__=='__main__' and sys.argv constructed as indicated. It thus
1415 __name__=='__main__' and sys.argv constructed as indicated. It thus
1416 sees its environment as if it were being run as a stand-alone program
1416 sees its environment as if it were being run as a stand-alone program
1417 (except for sharing global objects such as previously imported
1417 (except for sharing global objects such as previously imported
1418 modules). But after execution, the IPython interactive namespace gets
1418 modules). But after execution, the IPython interactive namespace gets
1419 updated with all variables defined in the program (except for __name__
1419 updated with all variables defined in the program (except for __name__
1420 and sys.argv). This allows for very convenient loading of code for
1420 and sys.argv). This allows for very convenient loading of code for
1421 interactive work, while giving each program a 'clean sheet' to run in.
1421 interactive work, while giving each program a 'clean sheet' to run in.
1422
1422
1423 Options:
1423 Options:
1424
1424
1425 -n: __name__ is NOT set to '__main__', but to the running file's name
1425 -n: __name__ is NOT set to '__main__', but to the running file's name
1426 without extension (as python does under import). This allows running
1426 without extension (as python does under import). This allows running
1427 scripts and reloading the definitions in them without calling code
1427 scripts and reloading the definitions in them without calling code
1428 protected by an ' if __name__ == "__main__" ' clause.
1428 protected by an ' if __name__ == "__main__" ' clause.
1429
1429
1430 -i: run the file in IPython's namespace instead of an empty one. This
1430 -i: run the file in IPython's namespace instead of an empty one. This
1431 is useful if you are experimenting with code written in a text editor
1431 is useful if you are experimenting with code written in a text editor
1432 which depends on variables defined interactively.
1432 which depends on variables defined interactively.
1433
1433
1434 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1434 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1435 being run. This is particularly useful if IPython is being used to
1435 being run. This is particularly useful if IPython is being used to
1436 run unittests, which always exit with a sys.exit() call. In such
1436 run unittests, which always exit with a sys.exit() call. In such
1437 cases you are interested in the output of the test results, not in
1437 cases you are interested in the output of the test results, not in
1438 seeing a traceback of the unittest module.
1438 seeing a traceback of the unittest module.
1439
1439
1440 -t: print timing information at the end of the run. IPython will give
1440 -t: print timing information at the end of the run. IPython will give
1441 you an estimated CPU time consumption for your script, which under
1441 you an estimated CPU time consumption for your script, which under
1442 Unix uses the resource module to avoid the wraparound problems of
1442 Unix uses the resource module to avoid the wraparound problems of
1443 time.clock(). Under Unix, an estimate of time spent on system tasks
1443 time.clock(). Under Unix, an estimate of time spent on system tasks
1444 is also given (for Windows platforms this is reported as 0.0).
1444 is also given (for Windows platforms this is reported as 0.0).
1445
1445
1446 If -t is given, an additional -N<N> option can be given, where <N>
1446 If -t is given, an additional -N<N> option can be given, where <N>
1447 must be an integer indicating how many times you want the script to
1447 must be an integer indicating how many times you want the script to
1448 run. The final timing report will include total and per run results.
1448 run. The final timing report will include total and per run results.
1449
1449
1450 For example (testing the script uniq_stable.py):
1450 For example (testing the script uniq_stable.py):
1451
1451
1452 In [1]: run -t uniq_stable
1452 In [1]: run -t uniq_stable
1453
1453
1454 IPython CPU timings (estimated):\\
1454 IPython CPU timings (estimated):\\
1455 User : 0.19597 s.\\
1455 User : 0.19597 s.\\
1456 System: 0.0 s.\\
1456 System: 0.0 s.\\
1457
1457
1458 In [2]: run -t -N5 uniq_stable
1458 In [2]: run -t -N5 uniq_stable
1459
1459
1460 IPython CPU timings (estimated):\\
1460 IPython CPU timings (estimated):\\
1461 Total runs performed: 5\\
1461 Total runs performed: 5\\
1462 Times : Total Per run\\
1462 Times : Total Per run\\
1463 User : 0.910862 s, 0.1821724 s.\\
1463 User : 0.910862 s, 0.1821724 s.\\
1464 System: 0.0 s, 0.0 s.
1464 System: 0.0 s, 0.0 s.
1465
1465
1466 -d: run your program under the control of pdb, the Python debugger.
1466 -d: run your program under the control of pdb, the Python debugger.
1467 This allows you to execute your program step by step, watch variables,
1467 This allows you to execute your program step by step, watch variables,
1468 etc. Internally, what IPython does is similar to calling:
1468 etc. Internally, what IPython does is similar to calling:
1469
1469
1470 pdb.run('execfile("YOURFILENAME")')
1470 pdb.run('execfile("YOURFILENAME")')
1471
1471
1472 with a breakpoint set on line 1 of your file. You can change the line
1472 with a breakpoint set on line 1 of your file. You can change the line
1473 number for this automatic breakpoint to be <N> by using the -bN option
1473 number for this automatic breakpoint to be <N> by using the -bN option
1474 (where N must be an integer). For example:
1474 (where N must be an integer). For example:
1475
1475
1476 %run -d -b40 myscript
1476 %run -d -b40 myscript
1477
1477
1478 will set the first breakpoint at line 40 in myscript.py. Note that
1478 will set the first breakpoint at line 40 in myscript.py. Note that
1479 the first breakpoint must be set on a line which actually does
1479 the first breakpoint must be set on a line which actually does
1480 something (not a comment or docstring) for it to stop execution.
1480 something (not a comment or docstring) for it to stop execution.
1481
1481
1482 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1482 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1483 first enter 'c' (without qoutes) to start execution up to the first
1483 first enter 'c' (without qoutes) to start execution up to the first
1484 breakpoint.
1484 breakpoint.
1485
1485
1486 Entering 'help' gives information about the use of the debugger. You
1486 Entering 'help' gives information about the use of the debugger. You
1487 can easily see pdb's full documentation with "import pdb;pdb.help()"
1487 can easily see pdb's full documentation with "import pdb;pdb.help()"
1488 at a prompt.
1488 at a prompt.
1489
1489
1490 -p: run program under the control of the Python profiler module (which
1490 -p: run program under the control of the Python profiler module (which
1491 prints a detailed report of execution times, function calls, etc).
1491 prints a detailed report of execution times, function calls, etc).
1492
1492
1493 You can pass other options after -p which affect the behavior of the
1493 You can pass other options after -p which affect the behavior of the
1494 profiler itself. See the docs for %prun for details.
1494 profiler itself. See the docs for %prun for details.
1495
1495
1496 In this mode, the program's variables do NOT propagate back to the
1496 In this mode, the program's variables do NOT propagate back to the
1497 IPython interactive namespace (because they remain in the namespace
1497 IPython interactive namespace (because they remain in the namespace
1498 where the profiler executes them).
1498 where the profiler executes them).
1499
1499
1500 Internally this triggers a call to %prun, see its documentation for
1500 Internally this triggers a call to %prun, see its documentation for
1501 details on the options available specifically for profiling.
1501 details on the options available specifically for profiling.
1502
1502
1503 There is one special usage for which the text above doesn't apply:
1503 There is one special usage for which the text above doesn't apply:
1504 if the filename ends with .ipy, the file is run as ipython script,
1504 if the filename ends with .ipy, the file is run as ipython script,
1505 just as if the commands were written on IPython prompt.
1505 just as if the commands were written on IPython prompt.
1506 """
1506 """
1507
1507
1508 # get arguments and set sys.argv for program to be run.
1508 # get arguments and set sys.argv for program to be run.
1509 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1509 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1510 mode='list',list_all=1)
1510 mode='list',list_all=1)
1511
1511
1512 try:
1512 try:
1513 filename = get_py_filename(arg_lst[0])
1513 filename = get_py_filename(arg_lst[0])
1514 except IndexError:
1514 except IndexError:
1515 warn('you must provide at least a filename.')
1515 warn('you must provide at least a filename.')
1516 print '\n%run:\n',OInspect.getdoc(self.magic_run)
1516 print '\n%run:\n',OInspect.getdoc(self.magic_run)
1517 return
1517 return
1518 except IOError,msg:
1518 except IOError,msg:
1519 error(msg)
1519 error(msg)
1520 return
1520 return
1521
1521
1522 if filename.lower().endswith('.ipy'):
1522 if filename.lower().endswith('.ipy'):
1523 self.api.runlines(open(filename).read())
1523 self.api.runlines(open(filename).read())
1524 return
1524 return
1525
1525
1526 # Control the response to exit() calls made by the script being run
1526 # Control the response to exit() calls made by the script being run
1527 exit_ignore = opts.has_key('e')
1527 exit_ignore = opts.has_key('e')
1528
1528
1529 # Make sure that the running script gets a proper sys.argv as if it
1529 # Make sure that the running script gets a proper sys.argv as if it
1530 # were run from a system shell.
1530 # were run from a system shell.
1531 save_argv = sys.argv # save it for later restoring
1531 save_argv = sys.argv # save it for later restoring
1532 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1532 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1533
1533
1534 if opts.has_key('i'):
1534 if opts.has_key('i'):
1535 # Run in user's interactive namespace
1535 # Run in user's interactive namespace
1536 prog_ns = self.shell.user_ns
1536 prog_ns = self.shell.user_ns
1537 __name__save = self.shell.user_ns['__name__']
1537 __name__save = self.shell.user_ns['__name__']
1538 prog_ns['__name__'] = '__main__'
1538 prog_ns['__name__'] = '__main__'
1539 main_mod = FakeModule(prog_ns)
1539 main_mod = FakeModule(prog_ns)
1540 else:
1540 else:
1541 # Run in a fresh, empty namespace
1541 # Run in a fresh, empty namespace
1542 if opts.has_key('n'):
1542 if opts.has_key('n'):
1543 name = os.path.splitext(os.path.basename(filename))[0]
1543 name = os.path.splitext(os.path.basename(filename))[0]
1544 else:
1544 else:
1545 name = '__main__'
1545 name = '__main__'
1546 main_mod = FakeModule()
1546 main_mod = FakeModule()
1547 prog_ns = main_mod.__dict__
1547 prog_ns = main_mod.__dict__
1548 prog_ns['__name__'] = name
1548 prog_ns['__name__'] = name
1549 # The shell MUST hold a reference to main_mod so after %run exits,
1549 # The shell MUST hold a reference to main_mod so after %run exits,
1550 # the python deletion mechanism doesn't zero it out (leaving
1550 # the python deletion mechanism doesn't zero it out (leaving
1551 # dangling references)
1551 # dangling references)
1552 self.shell._user_main_modules.append(main_mod)
1552 self.shell._user_main_modules.append(main_mod)
1553
1553
1554 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1554 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1555 # set the __file__ global in the script's namespace
1555 # set the __file__ global in the script's namespace
1556 prog_ns['__file__'] = filename
1556 prog_ns['__file__'] = filename
1557
1557
1558 # pickle fix. See iplib for an explanation. But we need to make sure
1558 # pickle fix. See iplib for an explanation. But we need to make sure
1559 # that, if we overwrite __main__, we replace it at the end
1559 # that, if we overwrite __main__, we replace it at the end
1560 if prog_ns['__name__'] == '__main__':
1560 if prog_ns['__name__'] == '__main__':
1561 restore_main = sys.modules['__main__']
1561 restore_main = sys.modules['__main__']
1562 else:
1562 else:
1563 restore_main = False
1563 restore_main = False
1564
1564
1565 sys.modules[prog_ns['__name__']] = main_mod
1565 sys.modules[prog_ns['__name__']] = main_mod
1566
1566
1567 stats = None
1567 stats = None
1568 try:
1568 try:
1569 if self.shell.has_readline:
1570 self.shell.savehist()
1569 self.shell.savehist()
1571
1570
1572 if opts.has_key('p'):
1571 if opts.has_key('p'):
1573 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1572 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1574 else:
1573 else:
1575 if opts.has_key('d'):
1574 if opts.has_key('d'):
1576 deb = Debugger.Pdb(self.shell.rc.colors)
1575 deb = Debugger.Pdb(self.shell.rc.colors)
1577 # reset Breakpoint state, which is moronically kept
1576 # reset Breakpoint state, which is moronically kept
1578 # in a class
1577 # in a class
1579 bdb.Breakpoint.next = 1
1578 bdb.Breakpoint.next = 1
1580 bdb.Breakpoint.bplist = {}
1579 bdb.Breakpoint.bplist = {}
1581 bdb.Breakpoint.bpbynumber = [None]
1580 bdb.Breakpoint.bpbynumber = [None]
1582 # Set an initial breakpoint to stop execution
1581 # Set an initial breakpoint to stop execution
1583 maxtries = 10
1582 maxtries = 10
1584 bp = int(opts.get('b',[1])[0])
1583 bp = int(opts.get('b',[1])[0])
1585 checkline = deb.checkline(filename,bp)
1584 checkline = deb.checkline(filename,bp)
1586 if not checkline:
1585 if not checkline:
1587 for bp in range(bp+1,bp+maxtries+1):
1586 for bp in range(bp+1,bp+maxtries+1):
1588 if deb.checkline(filename,bp):
1587 if deb.checkline(filename,bp):
1589 break
1588 break
1590 else:
1589 else:
1591 msg = ("\nI failed to find a valid line to set "
1590 msg = ("\nI failed to find a valid line to set "
1592 "a breakpoint\n"
1591 "a breakpoint\n"
1593 "after trying up to line: %s.\n"
1592 "after trying up to line: %s.\n"
1594 "Please set a valid breakpoint manually "
1593 "Please set a valid breakpoint manually "
1595 "with the -b option." % bp)
1594 "with the -b option." % bp)
1596 error(msg)
1595 error(msg)
1597 return
1596 return
1598 # if we find a good linenumber, set the breakpoint
1597 # if we find a good linenumber, set the breakpoint
1599 deb.do_break('%s:%s' % (filename,bp))
1598 deb.do_break('%s:%s' % (filename,bp))
1600 # Start file run
1599 # Start file run
1601 print "NOTE: Enter 'c' at the",
1600 print "NOTE: Enter 'c' at the",
1602 print "%s prompt to start your script." % deb.prompt
1601 print "%s prompt to start your script." % deb.prompt
1603 try:
1602 try:
1604 deb.run('execfile("%s")' % filename,prog_ns)
1603 deb.run('execfile("%s")' % filename,prog_ns)
1605
1604
1606 except:
1605 except:
1607 etype, value, tb = sys.exc_info()
1606 etype, value, tb = sys.exc_info()
1608 # Skip three frames in the traceback: the %run one,
1607 # Skip three frames in the traceback: the %run one,
1609 # one inside bdb.py, and the command-line typed by the
1608 # one inside bdb.py, and the command-line typed by the
1610 # user (run by exec in pdb itself).
1609 # user (run by exec in pdb itself).
1611 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1610 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1612 else:
1611 else:
1613 if runner is None:
1612 if runner is None:
1614 runner = self.shell.safe_execfile
1613 runner = self.shell.safe_execfile
1615 if opts.has_key('t'):
1614 if opts.has_key('t'):
1616 # timed execution
1615 # timed execution
1617 try:
1616 try:
1618 nruns = int(opts['N'][0])
1617 nruns = int(opts['N'][0])
1619 if nruns < 1:
1618 if nruns < 1:
1620 error('Number of runs must be >=1')
1619 error('Number of runs must be >=1')
1621 return
1620 return
1622 except (KeyError):
1621 except (KeyError):
1623 nruns = 1
1622 nruns = 1
1624 if nruns == 1:
1623 if nruns == 1:
1625 t0 = clock2()
1624 t0 = clock2()
1626 runner(filename,prog_ns,prog_ns,
1625 runner(filename,prog_ns,prog_ns,
1627 exit_ignore=exit_ignore)
1626 exit_ignore=exit_ignore)
1628 t1 = clock2()
1627 t1 = clock2()
1629 t_usr = t1[0]-t0[0]
1628 t_usr = t1[0]-t0[0]
1630 t_sys = t1[1]-t1[1]
1629 t_sys = t1[1]-t1[1]
1631 print "\nIPython CPU timings (estimated):"
1630 print "\nIPython CPU timings (estimated):"
1632 print " User : %10s s." % t_usr
1631 print " User : %10s s." % t_usr
1633 print " System: %10s s." % t_sys
1632 print " System: %10s s." % t_sys
1634 else:
1633 else:
1635 runs = range(nruns)
1634 runs = range(nruns)
1636 t0 = clock2()
1635 t0 = clock2()
1637 for nr in runs:
1636 for nr in runs:
1638 runner(filename,prog_ns,prog_ns,
1637 runner(filename,prog_ns,prog_ns,
1639 exit_ignore=exit_ignore)
1638 exit_ignore=exit_ignore)
1640 t1 = clock2()
1639 t1 = clock2()
1641 t_usr = t1[0]-t0[0]
1640 t_usr = t1[0]-t0[0]
1642 t_sys = t1[1]-t1[1]
1641 t_sys = t1[1]-t1[1]
1643 print "\nIPython CPU timings (estimated):"
1642 print "\nIPython CPU timings (estimated):"
1644 print "Total runs performed:",nruns
1643 print "Total runs performed:",nruns
1645 print " Times : %10s %10s" % ('Total','Per run')
1644 print " Times : %10s %10s" % ('Total','Per run')
1646 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1645 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1647 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1646 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1648
1647
1649 else:
1648 else:
1650 # regular execution
1649 # regular execution
1651 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1650 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1652 if opts.has_key('i'):
1651 if opts.has_key('i'):
1653 self.shell.user_ns['__name__'] = __name__save
1652 self.shell.user_ns['__name__'] = __name__save
1654 else:
1653 else:
1655 # update IPython interactive namespace
1654 # update IPython interactive namespace
1656 del prog_ns['__name__']
1655 del prog_ns['__name__']
1657 self.shell.user_ns.update(prog_ns)
1656 self.shell.user_ns.update(prog_ns)
1658 finally:
1657 finally:
1659 sys.argv = save_argv
1658 sys.argv = save_argv
1660 if restore_main:
1659 if restore_main:
1661 sys.modules['__main__'] = restore_main
1660 sys.modules['__main__'] = restore_main
1662 self.shell.reloadhist()
1661 self.shell.reloadhist()
1663
1662
1664 return stats
1663 return stats
1665
1664
1666 def magic_runlog(self, parameter_s =''):
1665 def magic_runlog(self, parameter_s =''):
1667 """Run files as logs.
1666 """Run files as logs.
1668
1667
1669 Usage:\\
1668 Usage:\\
1670 %runlog file1 file2 ...
1669 %runlog file1 file2 ...
1671
1670
1672 Run the named files (treating them as log files) in sequence inside
1671 Run the named files (treating them as log files) in sequence inside
1673 the interpreter, and return to the prompt. This is much slower than
1672 the interpreter, and return to the prompt. This is much slower than
1674 %run because each line is executed in a try/except block, but it
1673 %run because each line is executed in a try/except block, but it
1675 allows running files with syntax errors in them.
1674 allows running files with syntax errors in them.
1676
1675
1677 Normally IPython will guess when a file is one of its own logfiles, so
1676 Normally IPython will guess when a file is one of its own logfiles, so
1678 you can typically use %run even for logs. This shorthand allows you to
1677 you can typically use %run even for logs. This shorthand allows you to
1679 force any file to be treated as a log file."""
1678 force any file to be treated as a log file."""
1680
1679
1681 for f in parameter_s.split():
1680 for f in parameter_s.split():
1682 self.shell.safe_execfile(f,self.shell.user_ns,
1681 self.shell.safe_execfile(f,self.shell.user_ns,
1683 self.shell.user_ns,islog=1)
1682 self.shell.user_ns,islog=1)
1684
1683
1685 def magic_timeit(self, parameter_s =''):
1684 def magic_timeit(self, parameter_s =''):
1686 """Time execution of a Python statement or expression
1685 """Time execution of a Python statement or expression
1687
1686
1688 Usage:\\
1687 Usage:\\
1689 %timeit [-n<N> -r<R> [-t|-c]] statement
1688 %timeit [-n<N> -r<R> [-t|-c]] statement
1690
1689
1691 Time execution of a Python statement or expression using the timeit
1690 Time execution of a Python statement or expression using the timeit
1692 module.
1691 module.
1693
1692
1694 Options:
1693 Options:
1695 -n<N>: execute the given statement <N> times in a loop. If this value
1694 -n<N>: execute the given statement <N> times in a loop. If this value
1696 is not given, a fitting value is chosen.
1695 is not given, a fitting value is chosen.
1697
1696
1698 -r<R>: repeat the loop iteration <R> times and take the best result.
1697 -r<R>: repeat the loop iteration <R> times and take the best result.
1699 Default: 3
1698 Default: 3
1700
1699
1701 -t: use time.time to measure the time, which is the default on Unix.
1700 -t: use time.time to measure the time, which is the default on Unix.
1702 This function measures wall time.
1701 This function measures wall time.
1703
1702
1704 -c: use time.clock to measure the time, which is the default on
1703 -c: use time.clock to measure the time, which is the default on
1705 Windows and measures wall time. On Unix, resource.getrusage is used
1704 Windows and measures wall time. On Unix, resource.getrusage is used
1706 instead and returns the CPU user time.
1705 instead and returns the CPU user time.
1707
1706
1708 -p<P>: use a precision of <P> digits to display the timing result.
1707 -p<P>: use a precision of <P> digits to display the timing result.
1709 Default: 3
1708 Default: 3
1710
1709
1711
1710
1712 Examples:\\
1711 Examples:\\
1713 In [1]: %timeit pass
1712 In [1]: %timeit pass
1714 10000000 loops, best of 3: 53.3 ns per loop
1713 10000000 loops, best of 3: 53.3 ns per loop
1715
1714
1716 In [2]: u = None
1715 In [2]: u = None
1717
1716
1718 In [3]: %timeit u is None
1717 In [3]: %timeit u is None
1719 10000000 loops, best of 3: 184 ns per loop
1718 10000000 loops, best of 3: 184 ns per loop
1720
1719
1721 In [4]: %timeit -r 4 u == None
1720 In [4]: %timeit -r 4 u == None
1722 1000000 loops, best of 4: 242 ns per loop
1721 1000000 loops, best of 4: 242 ns per loop
1723
1722
1724 In [5]: import time
1723 In [5]: import time
1725
1724
1726 In [6]: %timeit -n1 time.sleep(2)
1725 In [6]: %timeit -n1 time.sleep(2)
1727 1 loops, best of 3: 2 s per loop
1726 1 loops, best of 3: 2 s per loop
1728
1727
1729
1728
1730 The times reported by %timeit will be slightly higher than those
1729 The times reported by %timeit will be slightly higher than those
1731 reported by the timeit.py script when variables are accessed. This is
1730 reported by the timeit.py script when variables are accessed. This is
1732 due to the fact that %timeit executes the statement in the namespace
1731 due to the fact that %timeit executes the statement in the namespace
1733 of the shell, compared with timeit.py, which uses a single setup
1732 of the shell, compared with timeit.py, which uses a single setup
1734 statement to import function or create variables. Generally, the bias
1733 statement to import function or create variables. Generally, the bias
1735 does not matter as long as results from timeit.py are not mixed with
1734 does not matter as long as results from timeit.py are not mixed with
1736 those from %timeit."""
1735 those from %timeit."""
1737
1736
1738 import timeit
1737 import timeit
1739 import math
1738 import math
1740
1739
1741 units = ["s", "ms", "\xc2\xb5s", "ns"]
1740 units = ["s", "ms", "\xc2\xb5s", "ns"]
1742 scaling = [1, 1e3, 1e6, 1e9]
1741 scaling = [1, 1e3, 1e6, 1e9]
1743
1742
1744 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1743 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1745 posix=False)
1744 posix=False)
1746 if stmt == "":
1745 if stmt == "":
1747 return
1746 return
1748 timefunc = timeit.default_timer
1747 timefunc = timeit.default_timer
1749 number = int(getattr(opts, "n", 0))
1748 number = int(getattr(opts, "n", 0))
1750 repeat = int(getattr(opts, "r", timeit.default_repeat))
1749 repeat = int(getattr(opts, "r", timeit.default_repeat))
1751 precision = int(getattr(opts, "p", 3))
1750 precision = int(getattr(opts, "p", 3))
1752 if hasattr(opts, "t"):
1751 if hasattr(opts, "t"):
1753 timefunc = time.time
1752 timefunc = time.time
1754 if hasattr(opts, "c"):
1753 if hasattr(opts, "c"):
1755 timefunc = clock
1754 timefunc = clock
1756
1755
1757 timer = timeit.Timer(timer=timefunc)
1756 timer = timeit.Timer(timer=timefunc)
1758 # this code has tight coupling to the inner workings of timeit.Timer,
1757 # this code has tight coupling to the inner workings of timeit.Timer,
1759 # but is there a better way to achieve that the code stmt has access
1758 # but is there a better way to achieve that the code stmt has access
1760 # to the shell namespace?
1759 # to the shell namespace?
1761
1760
1762 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1761 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1763 'setup': "pass"}
1762 'setup': "pass"}
1764 # Track compilation time so it can be reported if too long
1763 # Track compilation time so it can be reported if too long
1765 # Minimum time above which compilation time will be reported
1764 # Minimum time above which compilation time will be reported
1766 tc_min = 0.1
1765 tc_min = 0.1
1767
1766
1768 t0 = clock()
1767 t0 = clock()
1769 code = compile(src, "<magic-timeit>", "exec")
1768 code = compile(src, "<magic-timeit>", "exec")
1770 tc = clock()-t0
1769 tc = clock()-t0
1771
1770
1772 ns = {}
1771 ns = {}
1773 exec code in self.shell.user_ns, ns
1772 exec code in self.shell.user_ns, ns
1774 timer.inner = ns["inner"]
1773 timer.inner = ns["inner"]
1775
1774
1776 if number == 0:
1775 if number == 0:
1777 # determine number so that 0.2 <= total time < 2.0
1776 # determine number so that 0.2 <= total time < 2.0
1778 number = 1
1777 number = 1
1779 for i in range(1, 10):
1778 for i in range(1, 10):
1780 number *= 10
1779 number *= 10
1781 if timer.timeit(number) >= 0.2:
1780 if timer.timeit(number) >= 0.2:
1782 break
1781 break
1783
1782
1784 best = min(timer.repeat(repeat, number)) / number
1783 best = min(timer.repeat(repeat, number)) / number
1785
1784
1786 if best > 0.0:
1785 if best > 0.0:
1787 order = min(-int(math.floor(math.log10(best)) // 3), 3)
1786 order = min(-int(math.floor(math.log10(best)) // 3), 3)
1788 else:
1787 else:
1789 order = 3
1788 order = 3
1790 print "%d loops, best of %d: %.*g %s per loop" % (number, repeat,
1789 print "%d loops, best of %d: %.*g %s per loop" % (number, repeat,
1791 precision,
1790 precision,
1792 best * scaling[order],
1791 best * scaling[order],
1793 units[order])
1792 units[order])
1794 if tc > tc_min:
1793 if tc > tc_min:
1795 print "Compiler time: %.2f s" % tc
1794 print "Compiler time: %.2f s" % tc
1796
1795
1797 def magic_time(self,parameter_s = ''):
1796 def magic_time(self,parameter_s = ''):
1798 """Time execution of a Python statement or expression.
1797 """Time execution of a Python statement or expression.
1799
1798
1800 The CPU and wall clock times are printed, and the value of the
1799 The CPU and wall clock times are printed, and the value of the
1801 expression (if any) is returned. Note that under Win32, system time
1800 expression (if any) is returned. Note that under Win32, system time
1802 is always reported as 0, since it can not be measured.
1801 is always reported as 0, since it can not be measured.
1803
1802
1804 This function provides very basic timing functionality. In Python
1803 This function provides very basic timing functionality. In Python
1805 2.3, the timeit module offers more control and sophistication, so this
1804 2.3, the timeit module offers more control and sophistication, so this
1806 could be rewritten to use it (patches welcome).
1805 could be rewritten to use it (patches welcome).
1807
1806
1808 Some examples:
1807 Some examples:
1809
1808
1810 In [1]: time 2**128
1809 In [1]: time 2**128
1811 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1810 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1812 Wall time: 0.00
1811 Wall time: 0.00
1813 Out[1]: 340282366920938463463374607431768211456L
1812 Out[1]: 340282366920938463463374607431768211456L
1814
1813
1815 In [2]: n = 1000000
1814 In [2]: n = 1000000
1816
1815
1817 In [3]: time sum(range(n))
1816 In [3]: time sum(range(n))
1818 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1817 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1819 Wall time: 1.37
1818 Wall time: 1.37
1820 Out[3]: 499999500000L
1819 Out[3]: 499999500000L
1821
1820
1822 In [4]: time print 'hello world'
1821 In [4]: time print 'hello world'
1823 hello world
1822 hello world
1824 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1823 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1825 Wall time: 0.00
1824 Wall time: 0.00
1826
1825
1827 Note that the time needed by Python to compile the given expression
1826 Note that the time needed by Python to compile the given expression
1828 will be reported if it is more than 0.1s. In this example, the
1827 will be reported if it is more than 0.1s. In this example, the
1829 actual exponentiation is done by Python at compilation time, so while
1828 actual exponentiation is done by Python at compilation time, so while
1830 the expression can take a noticeable amount of time to compute, that
1829 the expression can take a noticeable amount of time to compute, that
1831 time is purely due to the compilation:
1830 time is purely due to the compilation:
1832
1831
1833 In [5]: time 3**9999;
1832 In [5]: time 3**9999;
1834 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1833 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1835 Wall time: 0.00 s
1834 Wall time: 0.00 s
1836
1835
1837 In [6]: time 3**999999;
1836 In [6]: time 3**999999;
1838 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1837 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1839 Wall time: 0.00 s
1838 Wall time: 0.00 s
1840 Compiler : 0.78 s
1839 Compiler : 0.78 s
1841 """
1840 """
1842
1841
1843 # fail immediately if the given expression can't be compiled
1842 # fail immediately if the given expression can't be compiled
1844
1843
1845 expr = self.shell.prefilter(parameter_s,False)
1844 expr = self.shell.prefilter(parameter_s,False)
1846
1845
1847 # Minimum time above which compilation time will be reported
1846 # Minimum time above which compilation time will be reported
1848 tc_min = 0.1
1847 tc_min = 0.1
1849
1848
1850 try:
1849 try:
1851 mode = 'eval'
1850 mode = 'eval'
1852 t0 = clock()
1851 t0 = clock()
1853 code = compile(expr,'<timed eval>',mode)
1852 code = compile(expr,'<timed eval>',mode)
1854 tc = clock()-t0
1853 tc = clock()-t0
1855 except SyntaxError:
1854 except SyntaxError:
1856 mode = 'exec'
1855 mode = 'exec'
1857 t0 = clock()
1856 t0 = clock()
1858 code = compile(expr,'<timed exec>',mode)
1857 code = compile(expr,'<timed exec>',mode)
1859 tc = clock()-t0
1858 tc = clock()-t0
1860 # skew measurement as little as possible
1859 # skew measurement as little as possible
1861 glob = self.shell.user_ns
1860 glob = self.shell.user_ns
1862 clk = clock2
1861 clk = clock2
1863 wtime = time.time
1862 wtime = time.time
1864 # time execution
1863 # time execution
1865 wall_st = wtime()
1864 wall_st = wtime()
1866 if mode=='eval':
1865 if mode=='eval':
1867 st = clk()
1866 st = clk()
1868 out = eval(code,glob)
1867 out = eval(code,glob)
1869 end = clk()
1868 end = clk()
1870 else:
1869 else:
1871 st = clk()
1870 st = clk()
1872 exec code in glob
1871 exec code in glob
1873 end = clk()
1872 end = clk()
1874 out = None
1873 out = None
1875 wall_end = wtime()
1874 wall_end = wtime()
1876 # Compute actual times and report
1875 # Compute actual times and report
1877 wall_time = wall_end-wall_st
1876 wall_time = wall_end-wall_st
1878 cpu_user = end[0]-st[0]
1877 cpu_user = end[0]-st[0]
1879 cpu_sys = end[1]-st[1]
1878 cpu_sys = end[1]-st[1]
1880 cpu_tot = cpu_user+cpu_sys
1879 cpu_tot = cpu_user+cpu_sys
1881 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1880 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1882 (cpu_user,cpu_sys,cpu_tot)
1881 (cpu_user,cpu_sys,cpu_tot)
1883 print "Wall time: %.2f s" % wall_time
1882 print "Wall time: %.2f s" % wall_time
1884 if tc > tc_min:
1883 if tc > tc_min:
1885 print "Compiler : %.2f s" % tc
1884 print "Compiler : %.2f s" % tc
1886 return out
1885 return out
1887
1886
1888 def magic_macro(self,parameter_s = ''):
1887 def magic_macro(self,parameter_s = ''):
1889 """Define a set of input lines as a macro for future re-execution.
1888 """Define a set of input lines as a macro for future re-execution.
1890
1889
1891 Usage:\\
1890 Usage:\\
1892 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
1891 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
1893
1892
1894 Options:
1893 Options:
1895
1894
1896 -r: use 'raw' input. By default, the 'processed' history is used,
1895 -r: use 'raw' input. By default, the 'processed' history is used,
1897 so that magics are loaded in their transformed version to valid
1896 so that magics are loaded in their transformed version to valid
1898 Python. If this option is given, the raw input as typed as the
1897 Python. If this option is given, the raw input as typed as the
1899 command line is used instead.
1898 command line is used instead.
1900
1899
1901 This will define a global variable called `name` which is a string
1900 This will define a global variable called `name` which is a string
1902 made of joining the slices and lines you specify (n1,n2,... numbers
1901 made of joining the slices and lines you specify (n1,n2,... numbers
1903 above) from your input history into a single string. This variable
1902 above) from your input history into a single string. This variable
1904 acts like an automatic function which re-executes those lines as if
1903 acts like an automatic function which re-executes those lines as if
1905 you had typed them. You just type 'name' at the prompt and the code
1904 you had typed them. You just type 'name' at the prompt and the code
1906 executes.
1905 executes.
1907
1906
1908 The notation for indicating number ranges is: n1-n2 means 'use line
1907 The notation for indicating number ranges is: n1-n2 means 'use line
1909 numbers n1,...n2' (the endpoint is included). That is, '5-7' means
1908 numbers n1,...n2' (the endpoint is included). That is, '5-7' means
1910 using the lines numbered 5,6 and 7.
1909 using the lines numbered 5,6 and 7.
1911
1910
1912 Note: as a 'hidden' feature, you can also use traditional python slice
1911 Note: as a 'hidden' feature, you can also use traditional python slice
1913 notation, where N:M means numbers N through M-1.
1912 notation, where N:M means numbers N through M-1.
1914
1913
1915 For example, if your history contains (%hist prints it):
1914 For example, if your history contains (%hist prints it):
1916
1915
1917 44: x=1\\
1916 44: x=1\\
1918 45: y=3\\
1917 45: y=3\\
1919 46: z=x+y\\
1918 46: z=x+y\\
1920 47: print x\\
1919 47: print x\\
1921 48: a=5\\
1920 48: a=5\\
1922 49: print 'x',x,'y',y\\
1921 49: print 'x',x,'y',y\\
1923
1922
1924 you can create a macro with lines 44 through 47 (included) and line 49
1923 you can create a macro with lines 44 through 47 (included) and line 49
1925 called my_macro with:
1924 called my_macro with:
1926
1925
1927 In [51]: %macro my_macro 44-47 49
1926 In [51]: %macro my_macro 44-47 49
1928
1927
1929 Now, typing `my_macro` (without quotes) will re-execute all this code
1928 Now, typing `my_macro` (without quotes) will re-execute all this code
1930 in one pass.
1929 in one pass.
1931
1930
1932 You don't need to give the line-numbers in order, and any given line
1931 You don't need to give the line-numbers in order, and any given line
1933 number can appear multiple times. You can assemble macros with any
1932 number can appear multiple times. You can assemble macros with any
1934 lines from your input history in any order.
1933 lines from your input history in any order.
1935
1934
1936 The macro is a simple object which holds its value in an attribute,
1935 The macro is a simple object which holds its value in an attribute,
1937 but IPython's display system checks for macros and executes them as
1936 but IPython's display system checks for macros and executes them as
1938 code instead of printing them when you type their name.
1937 code instead of printing them when you type their name.
1939
1938
1940 You can view a macro's contents by explicitly printing it with:
1939 You can view a macro's contents by explicitly printing it with:
1941
1940
1942 'print macro_name'.
1941 'print macro_name'.
1943
1942
1944 For one-off cases which DON'T contain magic function calls in them you
1943 For one-off cases which DON'T contain magic function calls in them you
1945 can obtain similar results by explicitly executing slices from your
1944 can obtain similar results by explicitly executing slices from your
1946 input history with:
1945 input history with:
1947
1946
1948 In [60]: exec In[44:48]+In[49]"""
1947 In [60]: exec In[44:48]+In[49]"""
1949
1948
1950 opts,args = self.parse_options(parameter_s,'r',mode='list')
1949 opts,args = self.parse_options(parameter_s,'r',mode='list')
1951 if not args:
1950 if not args:
1952 macs = [k for k,v in self.shell.user_ns.items() if isinstance(v, Macro)]
1951 macs = [k for k,v in self.shell.user_ns.items() if isinstance(v, Macro)]
1953 macs.sort()
1952 macs.sort()
1954 return macs
1953 return macs
1955 if len(args) == 1:
1954 if len(args) == 1:
1956 raise UsageError(
1955 raise UsageError(
1957 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
1956 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
1958 name,ranges = args[0], args[1:]
1957 name,ranges = args[0], args[1:]
1959
1958
1960 #print 'rng',ranges # dbg
1959 #print 'rng',ranges # dbg
1961 lines = self.extract_input_slices(ranges,opts.has_key('r'))
1960 lines = self.extract_input_slices(ranges,opts.has_key('r'))
1962 macro = Macro(lines)
1961 macro = Macro(lines)
1963 self.shell.user_ns.update({name:macro})
1962 self.shell.user_ns.update({name:macro})
1964 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
1963 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
1965 print 'Macro contents:'
1964 print 'Macro contents:'
1966 print macro,
1965 print macro,
1967
1966
1968 def magic_save(self,parameter_s = ''):
1967 def magic_save(self,parameter_s = ''):
1969 """Save a set of lines to a given filename.
1968 """Save a set of lines to a given filename.
1970
1969
1971 Usage:\\
1970 Usage:\\
1972 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
1971 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
1973
1972
1974 Options:
1973 Options:
1975
1974
1976 -r: use 'raw' input. By default, the 'processed' history is used,
1975 -r: use 'raw' input. By default, the 'processed' history is used,
1977 so that magics are loaded in their transformed version to valid
1976 so that magics are loaded in their transformed version to valid
1978 Python. If this option is given, the raw input as typed as the
1977 Python. If this option is given, the raw input as typed as the
1979 command line is used instead.
1978 command line is used instead.
1980
1979
1981 This function uses the same syntax as %macro for line extraction, but
1980 This function uses the same syntax as %macro for line extraction, but
1982 instead of creating a macro it saves the resulting string to the
1981 instead of creating a macro it saves the resulting string to the
1983 filename you specify.
1982 filename you specify.
1984
1983
1985 It adds a '.py' extension to the file if you don't do so yourself, and
1984 It adds a '.py' extension to the file if you don't do so yourself, and
1986 it asks for confirmation before overwriting existing files."""
1985 it asks for confirmation before overwriting existing files."""
1987
1986
1988 opts,args = self.parse_options(parameter_s,'r',mode='list')
1987 opts,args = self.parse_options(parameter_s,'r',mode='list')
1989 fname,ranges = args[0], args[1:]
1988 fname,ranges = args[0], args[1:]
1990 if not fname.endswith('.py'):
1989 if not fname.endswith('.py'):
1991 fname += '.py'
1990 fname += '.py'
1992 if os.path.isfile(fname):
1991 if os.path.isfile(fname):
1993 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
1992 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
1994 if ans.lower() not in ['y','yes']:
1993 if ans.lower() not in ['y','yes']:
1995 print 'Operation cancelled.'
1994 print 'Operation cancelled.'
1996 return
1995 return
1997 cmds = ''.join(self.extract_input_slices(ranges,opts.has_key('r')))
1996 cmds = ''.join(self.extract_input_slices(ranges,opts.has_key('r')))
1998 f = file(fname,'w')
1997 f = file(fname,'w')
1999 f.write(cmds)
1998 f.write(cmds)
2000 f.close()
1999 f.close()
2001 print 'The following commands were written to file `%s`:' % fname
2000 print 'The following commands were written to file `%s`:' % fname
2002 print cmds
2001 print cmds
2003
2002
2004 def _edit_macro(self,mname,macro):
2003 def _edit_macro(self,mname,macro):
2005 """open an editor with the macro data in a file"""
2004 """open an editor with the macro data in a file"""
2006 filename = self.shell.mktempfile(macro.value)
2005 filename = self.shell.mktempfile(macro.value)
2007 self.shell.hooks.editor(filename)
2006 self.shell.hooks.editor(filename)
2008
2007
2009 # and make a new macro object, to replace the old one
2008 # and make a new macro object, to replace the old one
2010 mfile = open(filename)
2009 mfile = open(filename)
2011 mvalue = mfile.read()
2010 mvalue = mfile.read()
2012 mfile.close()
2011 mfile.close()
2013 self.shell.user_ns[mname] = Macro(mvalue)
2012 self.shell.user_ns[mname] = Macro(mvalue)
2014
2013
2015 def magic_ed(self,parameter_s=''):
2014 def magic_ed(self,parameter_s=''):
2016 """Alias to %edit."""
2015 """Alias to %edit."""
2017 return self.magic_edit(parameter_s)
2016 return self.magic_edit(parameter_s)
2018
2017
2019 def magic_edit(self,parameter_s='',last_call=['','']):
2018 def magic_edit(self,parameter_s='',last_call=['','']):
2020 """Bring up an editor and execute the resulting code.
2019 """Bring up an editor and execute the resulting code.
2021
2020
2022 Usage:
2021 Usage:
2023 %edit [options] [args]
2022 %edit [options] [args]
2024
2023
2025 %edit runs IPython's editor hook. The default version of this hook is
2024 %edit runs IPython's editor hook. The default version of this hook is
2026 set to call the __IPYTHON__.rc.editor command. This is read from your
2025 set to call the __IPYTHON__.rc.editor command. This is read from your
2027 environment variable $EDITOR. If this isn't found, it will default to
2026 environment variable $EDITOR. If this isn't found, it will default to
2028 vi under Linux/Unix and to notepad under Windows. See the end of this
2027 vi under Linux/Unix and to notepad under Windows. See the end of this
2029 docstring for how to change the editor hook.
2028 docstring for how to change the editor hook.
2030
2029
2031 You can also set the value of this editor via the command line option
2030 You can also set the value of this editor via the command line option
2032 '-editor' or in your ipythonrc file. This is useful if you wish to use
2031 '-editor' or in your ipythonrc file. This is useful if you wish to use
2033 specifically for IPython an editor different from your typical default
2032 specifically for IPython an editor different from your typical default
2034 (and for Windows users who typically don't set environment variables).
2033 (and for Windows users who typically don't set environment variables).
2035
2034
2036 This command allows you to conveniently edit multi-line code right in
2035 This command allows you to conveniently edit multi-line code right in
2037 your IPython session.
2036 your IPython session.
2038
2037
2039 If called without arguments, %edit opens up an empty editor with a
2038 If called without arguments, %edit opens up an empty editor with a
2040 temporary file and will execute the contents of this file when you
2039 temporary file and will execute the contents of this file when you
2041 close it (don't forget to save it!).
2040 close it (don't forget to save it!).
2042
2041
2043
2042
2044 Options:
2043 Options:
2045
2044
2046 -n <number>: open the editor at a specified line number. By default,
2045 -n <number>: open the editor at a specified line number. By default,
2047 the IPython editor hook uses the unix syntax 'editor +N filename', but
2046 the IPython editor hook uses the unix syntax 'editor +N filename', but
2048 you can configure this by providing your own modified hook if your
2047 you can configure this by providing your own modified hook if your
2049 favorite editor supports line-number specifications with a different
2048 favorite editor supports line-number specifications with a different
2050 syntax.
2049 syntax.
2051
2050
2052 -p: this will call the editor with the same data as the previous time
2051 -p: this will call the editor with the same data as the previous time
2053 it was used, regardless of how long ago (in your current session) it
2052 it was used, regardless of how long ago (in your current session) it
2054 was.
2053 was.
2055
2054
2056 -r: use 'raw' input. This option only applies to input taken from the
2055 -r: use 'raw' input. This option only applies to input taken from the
2057 user's history. By default, the 'processed' history is used, so that
2056 user's history. By default, the 'processed' history is used, so that
2058 magics are loaded in their transformed version to valid Python. If
2057 magics are loaded in their transformed version to valid Python. If
2059 this option is given, the raw input as typed as the command line is
2058 this option is given, the raw input as typed as the command line is
2060 used instead. When you exit the editor, it will be executed by
2059 used instead. When you exit the editor, it will be executed by
2061 IPython's own processor.
2060 IPython's own processor.
2062
2061
2063 -x: do not execute the edited code immediately upon exit. This is
2062 -x: do not execute the edited code immediately upon exit. This is
2064 mainly useful if you are editing programs which need to be called with
2063 mainly useful if you are editing programs which need to be called with
2065 command line arguments, which you can then do using %run.
2064 command line arguments, which you can then do using %run.
2066
2065
2067
2066
2068 Arguments:
2067 Arguments:
2069
2068
2070 If arguments are given, the following possibilites exist:
2069 If arguments are given, the following possibilites exist:
2071
2070
2072 - The arguments are numbers or pairs of colon-separated numbers (like
2071 - The arguments are numbers or pairs of colon-separated numbers (like
2073 1 4:8 9). These are interpreted as lines of previous input to be
2072 1 4:8 9). These are interpreted as lines of previous input to be
2074 loaded into the editor. The syntax is the same of the %macro command.
2073 loaded into the editor. The syntax is the same of the %macro command.
2075
2074
2076 - If the argument doesn't start with a number, it is evaluated as a
2075 - If the argument doesn't start with a number, it is evaluated as a
2077 variable and its contents loaded into the editor. You can thus edit
2076 variable and its contents loaded into the editor. You can thus edit
2078 any string which contains python code (including the result of
2077 any string which contains python code (including the result of
2079 previous edits).
2078 previous edits).
2080
2079
2081 - If the argument is the name of an object (other than a string),
2080 - If the argument is the name of an object (other than a string),
2082 IPython will try to locate the file where it was defined and open the
2081 IPython will try to locate the file where it was defined and open the
2083 editor at the point where it is defined. You can use `%edit function`
2082 editor at the point where it is defined. You can use `%edit function`
2084 to load an editor exactly at the point where 'function' is defined,
2083 to load an editor exactly at the point where 'function' is defined,
2085 edit it and have the file be executed automatically.
2084 edit it and have the file be executed automatically.
2086
2085
2087 If the object is a macro (see %macro for details), this opens up your
2086 If the object is a macro (see %macro for details), this opens up your
2088 specified editor with a temporary file containing the macro's data.
2087 specified editor with a temporary file containing the macro's data.
2089 Upon exit, the macro is reloaded with the contents of the file.
2088 Upon exit, the macro is reloaded with the contents of the file.
2090
2089
2091 Note: opening at an exact line is only supported under Unix, and some
2090 Note: opening at an exact line is only supported under Unix, and some
2092 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2091 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2093 '+NUMBER' parameter necessary for this feature. Good editors like
2092 '+NUMBER' parameter necessary for this feature. Good editors like
2094 (X)Emacs, vi, jed, pico and joe all do.
2093 (X)Emacs, vi, jed, pico and joe all do.
2095
2094
2096 - If the argument is not found as a variable, IPython will look for a
2095 - If the argument is not found as a variable, IPython will look for a
2097 file with that name (adding .py if necessary) and load it into the
2096 file with that name (adding .py if necessary) and load it into the
2098 editor. It will execute its contents with execfile() when you exit,
2097 editor. It will execute its contents with execfile() when you exit,
2099 loading any code in the file into your interactive namespace.
2098 loading any code in the file into your interactive namespace.
2100
2099
2101 After executing your code, %edit will return as output the code you
2100 After executing your code, %edit will return as output the code you
2102 typed in the editor (except when it was an existing file). This way
2101 typed in the editor (except when it was an existing file). This way
2103 you can reload the code in further invocations of %edit as a variable,
2102 you can reload the code in further invocations of %edit as a variable,
2104 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2103 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2105 the output.
2104 the output.
2106
2105
2107 Note that %edit is also available through the alias %ed.
2106 Note that %edit is also available through the alias %ed.
2108
2107
2109 This is an example of creating a simple function inside the editor and
2108 This is an example of creating a simple function inside the editor and
2110 then modifying it. First, start up the editor:
2109 then modifying it. First, start up the editor:
2111
2110
2112 In [1]: ed\\
2111 In [1]: ed\\
2113 Editing... done. Executing edited code...\\
2112 Editing... done. Executing edited code...\\
2114 Out[1]: 'def foo():\\n print "foo() was defined in an editing session"\\n'
2113 Out[1]: 'def foo():\\n print "foo() was defined in an editing session"\\n'
2115
2114
2116 We can then call the function foo():
2115 We can then call the function foo():
2117
2116
2118 In [2]: foo()\\
2117 In [2]: foo()\\
2119 foo() was defined in an editing session
2118 foo() was defined in an editing session
2120
2119
2121 Now we edit foo. IPython automatically loads the editor with the
2120 Now we edit foo. IPython automatically loads the editor with the
2122 (temporary) file where foo() was previously defined:
2121 (temporary) file where foo() was previously defined:
2123
2122
2124 In [3]: ed foo\\
2123 In [3]: ed foo\\
2125 Editing... done. Executing edited code...
2124 Editing... done. Executing edited code...
2126
2125
2127 And if we call foo() again we get the modified version:
2126 And if we call foo() again we get the modified version:
2128
2127
2129 In [4]: foo()\\
2128 In [4]: foo()\\
2130 foo() has now been changed!
2129 foo() has now been changed!
2131
2130
2132 Here is an example of how to edit a code snippet successive
2131 Here is an example of how to edit a code snippet successive
2133 times. First we call the editor:
2132 times. First we call the editor:
2134
2133
2135 In [8]: ed\\
2134 In [8]: ed\\
2136 Editing... done. Executing edited code...\\
2135 Editing... done. Executing edited code...\\
2137 hello\\
2136 hello\\
2138 Out[8]: "print 'hello'\\n"
2137 Out[8]: "print 'hello'\\n"
2139
2138
2140 Now we call it again with the previous output (stored in _):
2139 Now we call it again with the previous output (stored in _):
2141
2140
2142 In [9]: ed _\\
2141 In [9]: ed _\\
2143 Editing... done. Executing edited code...\\
2142 Editing... done. Executing edited code...\\
2144 hello world\\
2143 hello world\\
2145 Out[9]: "print 'hello world'\\n"
2144 Out[9]: "print 'hello world'\\n"
2146
2145
2147 Now we call it with the output #8 (stored in _8, also as Out[8]):
2146 Now we call it with the output #8 (stored in _8, also as Out[8]):
2148
2147
2149 In [10]: ed _8\\
2148 In [10]: ed _8\\
2150 Editing... done. Executing edited code...\\
2149 Editing... done. Executing edited code...\\
2151 hello again\\
2150 hello again\\
2152 Out[10]: "print 'hello again'\\n"
2151 Out[10]: "print 'hello again'\\n"
2153
2152
2154
2153
2155 Changing the default editor hook:
2154 Changing the default editor hook:
2156
2155
2157 If you wish to write your own editor hook, you can put it in a
2156 If you wish to write your own editor hook, you can put it in a
2158 configuration file which you load at startup time. The default hook
2157 configuration file which you load at startup time. The default hook
2159 is defined in the IPython.hooks module, and you can use that as a
2158 is defined in the IPython.hooks module, and you can use that as a
2160 starting example for further modifications. That file also has
2159 starting example for further modifications. That file also has
2161 general instructions on how to set a new hook for use once you've
2160 general instructions on how to set a new hook for use once you've
2162 defined it."""
2161 defined it."""
2163
2162
2164 # FIXME: This function has become a convoluted mess. It needs a
2163 # FIXME: This function has become a convoluted mess. It needs a
2165 # ground-up rewrite with clean, simple logic.
2164 # ground-up rewrite with clean, simple logic.
2166
2165
2167 def make_filename(arg):
2166 def make_filename(arg):
2168 "Make a filename from the given args"
2167 "Make a filename from the given args"
2169 try:
2168 try:
2170 filename = get_py_filename(arg)
2169 filename = get_py_filename(arg)
2171 except IOError:
2170 except IOError:
2172 if args.endswith('.py'):
2171 if args.endswith('.py'):
2173 filename = arg
2172 filename = arg
2174 else:
2173 else:
2175 filename = None
2174 filename = None
2176 return filename
2175 return filename
2177
2176
2178 # custom exceptions
2177 # custom exceptions
2179 class DataIsObject(Exception): pass
2178 class DataIsObject(Exception): pass
2180
2179
2181 opts,args = self.parse_options(parameter_s,'prxn:')
2180 opts,args = self.parse_options(parameter_s,'prxn:')
2182 # Set a few locals from the options for convenience:
2181 # Set a few locals from the options for convenience:
2183 opts_p = opts.has_key('p')
2182 opts_p = opts.has_key('p')
2184 opts_r = opts.has_key('r')
2183 opts_r = opts.has_key('r')
2185
2184
2186 # Default line number value
2185 # Default line number value
2187 lineno = opts.get('n',None)
2186 lineno = opts.get('n',None)
2188
2187
2189 if opts_p:
2188 if opts_p:
2190 args = '_%s' % last_call[0]
2189 args = '_%s' % last_call[0]
2191 if not self.shell.user_ns.has_key(args):
2190 if not self.shell.user_ns.has_key(args):
2192 args = last_call[1]
2191 args = last_call[1]
2193
2192
2194 # use last_call to remember the state of the previous call, but don't
2193 # use last_call to remember the state of the previous call, but don't
2195 # let it be clobbered by successive '-p' calls.
2194 # let it be clobbered by successive '-p' calls.
2196 try:
2195 try:
2197 last_call[0] = self.shell.outputcache.prompt_count
2196 last_call[0] = self.shell.outputcache.prompt_count
2198 if not opts_p:
2197 if not opts_p:
2199 last_call[1] = parameter_s
2198 last_call[1] = parameter_s
2200 except:
2199 except:
2201 pass
2200 pass
2202
2201
2203 # by default this is done with temp files, except when the given
2202 # by default this is done with temp files, except when the given
2204 # arg is a filename
2203 # arg is a filename
2205 use_temp = 1
2204 use_temp = 1
2206
2205
2207 if re.match(r'\d',args):
2206 if re.match(r'\d',args):
2208 # Mode where user specifies ranges of lines, like in %macro.
2207 # Mode where user specifies ranges of lines, like in %macro.
2209 # This means that you can't edit files whose names begin with
2208 # This means that you can't edit files whose names begin with
2210 # numbers this way. Tough.
2209 # numbers this way. Tough.
2211 ranges = args.split()
2210 ranges = args.split()
2212 data = ''.join(self.extract_input_slices(ranges,opts_r))
2211 data = ''.join(self.extract_input_slices(ranges,opts_r))
2213 elif args.endswith('.py'):
2212 elif args.endswith('.py'):
2214 filename = make_filename(args)
2213 filename = make_filename(args)
2215 data = ''
2214 data = ''
2216 use_temp = 0
2215 use_temp = 0
2217 elif args:
2216 elif args:
2218 try:
2217 try:
2219 # Load the parameter given as a variable. If not a string,
2218 # Load the parameter given as a variable. If not a string,
2220 # process it as an object instead (below)
2219 # process it as an object instead (below)
2221
2220
2222 #print '*** args',args,'type',type(args) # dbg
2221 #print '*** args',args,'type',type(args) # dbg
2223 data = eval(args,self.shell.user_ns)
2222 data = eval(args,self.shell.user_ns)
2224 if not type(data) in StringTypes:
2223 if not type(data) in StringTypes:
2225 raise DataIsObject
2224 raise DataIsObject
2226
2225
2227 except (NameError,SyntaxError):
2226 except (NameError,SyntaxError):
2228 # given argument is not a variable, try as a filename
2227 # given argument is not a variable, try as a filename
2229 filename = make_filename(args)
2228 filename = make_filename(args)
2230 if filename is None:
2229 if filename is None:
2231 warn("Argument given (%s) can't be found as a variable "
2230 warn("Argument given (%s) can't be found as a variable "
2232 "or as a filename." % args)
2231 "or as a filename." % args)
2233 return
2232 return
2234
2233
2235 data = ''
2234 data = ''
2236 use_temp = 0
2235 use_temp = 0
2237 except DataIsObject:
2236 except DataIsObject:
2238
2237
2239 # macros have a special edit function
2238 # macros have a special edit function
2240 if isinstance(data,Macro):
2239 if isinstance(data,Macro):
2241 self._edit_macro(args,data)
2240 self._edit_macro(args,data)
2242 return
2241 return
2243
2242
2244 # For objects, try to edit the file where they are defined
2243 # For objects, try to edit the file where they are defined
2245 try:
2244 try:
2246 filename = inspect.getabsfile(data)
2245 filename = inspect.getabsfile(data)
2247 datafile = 1
2246 datafile = 1
2248 except TypeError:
2247 except TypeError:
2249 filename = make_filename(args)
2248 filename = make_filename(args)
2250 datafile = 1
2249 datafile = 1
2251 warn('Could not find file where `%s` is defined.\n'
2250 warn('Could not find file where `%s` is defined.\n'
2252 'Opening a file named `%s`' % (args,filename))
2251 'Opening a file named `%s`' % (args,filename))
2253 # Now, make sure we can actually read the source (if it was in
2252 # Now, make sure we can actually read the source (if it was in
2254 # a temp file it's gone by now).
2253 # a temp file it's gone by now).
2255 if datafile:
2254 if datafile:
2256 try:
2255 try:
2257 if lineno is None:
2256 if lineno is None:
2258 lineno = inspect.getsourcelines(data)[1]
2257 lineno = inspect.getsourcelines(data)[1]
2259 except IOError:
2258 except IOError:
2260 filename = make_filename(args)
2259 filename = make_filename(args)
2261 if filename is None:
2260 if filename is None:
2262 warn('The file `%s` where `%s` was defined cannot '
2261 warn('The file `%s` where `%s` was defined cannot '
2263 'be read.' % (filename,data))
2262 'be read.' % (filename,data))
2264 return
2263 return
2265 use_temp = 0
2264 use_temp = 0
2266 else:
2265 else:
2267 data = ''
2266 data = ''
2268
2267
2269 if use_temp:
2268 if use_temp:
2270 filename = self.shell.mktempfile(data)
2269 filename = self.shell.mktempfile(data)
2271 print 'IPython will make a temporary file named:',filename
2270 print 'IPython will make a temporary file named:',filename
2272
2271
2273 # do actual editing here
2272 # do actual editing here
2274 print 'Editing...',
2273 print 'Editing...',
2275 sys.stdout.flush()
2274 sys.stdout.flush()
2276 self.shell.hooks.editor(filename,lineno)
2275 self.shell.hooks.editor(filename,lineno)
2277 if opts.has_key('x'): # -x prevents actual execution
2276 if opts.has_key('x'): # -x prevents actual execution
2278 print
2277 print
2279 else:
2278 else:
2280 print 'done. Executing edited code...'
2279 print 'done. Executing edited code...'
2281 if opts_r:
2280 if opts_r:
2282 self.shell.runlines(file_read(filename))
2281 self.shell.runlines(file_read(filename))
2283 else:
2282 else:
2284 self.shell.safe_execfile(filename,self.shell.user_ns,
2283 self.shell.safe_execfile(filename,self.shell.user_ns,
2285 self.shell.user_ns)
2284 self.shell.user_ns)
2286 if use_temp:
2285 if use_temp:
2287 try:
2286 try:
2288 return open(filename).read()
2287 return open(filename).read()
2289 except IOError,msg:
2288 except IOError,msg:
2290 if msg.filename == filename:
2289 if msg.filename == filename:
2291 warn('File not found. Did you forget to save?')
2290 warn('File not found. Did you forget to save?')
2292 return
2291 return
2293 else:
2292 else:
2294 self.shell.showtraceback()
2293 self.shell.showtraceback()
2295
2294
2296 def magic_xmode(self,parameter_s = ''):
2295 def magic_xmode(self,parameter_s = ''):
2297 """Switch modes for the exception handlers.
2296 """Switch modes for the exception handlers.
2298
2297
2299 Valid modes: Plain, Context and Verbose.
2298 Valid modes: Plain, Context and Verbose.
2300
2299
2301 If called without arguments, acts as a toggle."""
2300 If called without arguments, acts as a toggle."""
2302
2301
2303 def xmode_switch_err(name):
2302 def xmode_switch_err(name):
2304 warn('Error changing %s exception modes.\n%s' %
2303 warn('Error changing %s exception modes.\n%s' %
2305 (name,sys.exc_info()[1]))
2304 (name,sys.exc_info()[1]))
2306
2305
2307 shell = self.shell
2306 shell = self.shell
2308 new_mode = parameter_s.strip().capitalize()
2307 new_mode = parameter_s.strip().capitalize()
2309 try:
2308 try:
2310 shell.InteractiveTB.set_mode(mode=new_mode)
2309 shell.InteractiveTB.set_mode(mode=new_mode)
2311 print 'Exception reporting mode:',shell.InteractiveTB.mode
2310 print 'Exception reporting mode:',shell.InteractiveTB.mode
2312 except:
2311 except:
2313 xmode_switch_err('user')
2312 xmode_switch_err('user')
2314
2313
2315 # threaded shells use a special handler in sys.excepthook
2314 # threaded shells use a special handler in sys.excepthook
2316 if shell.isthreaded:
2315 if shell.isthreaded:
2317 try:
2316 try:
2318 shell.sys_excepthook.set_mode(mode=new_mode)
2317 shell.sys_excepthook.set_mode(mode=new_mode)
2319 except:
2318 except:
2320 xmode_switch_err('threaded')
2319 xmode_switch_err('threaded')
2321
2320
2322 def magic_colors(self,parameter_s = ''):
2321 def magic_colors(self,parameter_s = ''):
2323 """Switch color scheme for prompts, info system and exception handlers.
2322 """Switch color scheme for prompts, info system and exception handlers.
2324
2323
2325 Currently implemented schemes: NoColor, Linux, LightBG.
2324 Currently implemented schemes: NoColor, Linux, LightBG.
2326
2325
2327 Color scheme names are not case-sensitive."""
2326 Color scheme names are not case-sensitive."""
2328
2327
2329 def color_switch_err(name):
2328 def color_switch_err(name):
2330 warn('Error changing %s color schemes.\n%s' %
2329 warn('Error changing %s color schemes.\n%s' %
2331 (name,sys.exc_info()[1]))
2330 (name,sys.exc_info()[1]))
2332
2331
2333
2332
2334 new_scheme = parameter_s.strip()
2333 new_scheme = parameter_s.strip()
2335 if not new_scheme:
2334 if not new_scheme:
2336 raise UsageError(
2335 raise UsageError(
2337 "%colors: you must specify a color scheme. See '%colors?'")
2336 "%colors: you must specify a color scheme. See '%colors?'")
2338 return
2337 return
2339 # local shortcut
2338 # local shortcut
2340 shell = self.shell
2339 shell = self.shell
2341
2340
2342 import IPython.rlineimpl as readline
2341 import IPython.rlineimpl as readline
2343
2342
2344 if not readline.have_readline and sys.platform == "win32":
2343 if not readline.have_readline and sys.platform == "win32":
2345 msg = """\
2344 msg = """\
2346 Proper color support under MS Windows requires the pyreadline library.
2345 Proper color support under MS Windows requires the pyreadline library.
2347 You can find it at:
2346 You can find it at:
2348 http://ipython.scipy.org/moin/PyReadline/Intro
2347 http://ipython.scipy.org/moin/PyReadline/Intro
2349 Gary's readline needs the ctypes module, from:
2348 Gary's readline needs the ctypes module, from:
2350 http://starship.python.net/crew/theller/ctypes
2349 http://starship.python.net/crew/theller/ctypes
2351 (Note that ctypes is already part of Python versions 2.5 and newer).
2350 (Note that ctypes is already part of Python versions 2.5 and newer).
2352
2351
2353 Defaulting color scheme to 'NoColor'"""
2352 Defaulting color scheme to 'NoColor'"""
2354 new_scheme = 'NoColor'
2353 new_scheme = 'NoColor'
2355 warn(msg)
2354 warn(msg)
2356
2355
2357 # readline option is 0
2356 # readline option is 0
2358 if not shell.has_readline:
2357 if not shell.has_readline:
2359 new_scheme = 'NoColor'
2358 new_scheme = 'NoColor'
2360
2359
2361 # Set prompt colors
2360 # Set prompt colors
2362 try:
2361 try:
2363 shell.outputcache.set_colors(new_scheme)
2362 shell.outputcache.set_colors(new_scheme)
2364 except:
2363 except:
2365 color_switch_err('prompt')
2364 color_switch_err('prompt')
2366 else:
2365 else:
2367 shell.rc.colors = \
2366 shell.rc.colors = \
2368 shell.outputcache.color_table.active_scheme_name
2367 shell.outputcache.color_table.active_scheme_name
2369 # Set exception colors
2368 # Set exception colors
2370 try:
2369 try:
2371 shell.InteractiveTB.set_colors(scheme = new_scheme)
2370 shell.InteractiveTB.set_colors(scheme = new_scheme)
2372 shell.SyntaxTB.set_colors(scheme = new_scheme)
2371 shell.SyntaxTB.set_colors(scheme = new_scheme)
2373 except:
2372 except:
2374 color_switch_err('exception')
2373 color_switch_err('exception')
2375
2374
2376 # threaded shells use a verbose traceback in sys.excepthook
2375 # threaded shells use a verbose traceback in sys.excepthook
2377 if shell.isthreaded:
2376 if shell.isthreaded:
2378 try:
2377 try:
2379 shell.sys_excepthook.set_colors(scheme=new_scheme)
2378 shell.sys_excepthook.set_colors(scheme=new_scheme)
2380 except:
2379 except:
2381 color_switch_err('system exception handler')
2380 color_switch_err('system exception handler')
2382
2381
2383 # Set info (for 'object?') colors
2382 # Set info (for 'object?') colors
2384 if shell.rc.color_info:
2383 if shell.rc.color_info:
2385 try:
2384 try:
2386 shell.inspector.set_active_scheme(new_scheme)
2385 shell.inspector.set_active_scheme(new_scheme)
2387 except:
2386 except:
2388 color_switch_err('object inspector')
2387 color_switch_err('object inspector')
2389 else:
2388 else:
2390 shell.inspector.set_active_scheme('NoColor')
2389 shell.inspector.set_active_scheme('NoColor')
2391
2390
2392 def magic_color_info(self,parameter_s = ''):
2391 def magic_color_info(self,parameter_s = ''):
2393 """Toggle color_info.
2392 """Toggle color_info.
2394
2393
2395 The color_info configuration parameter controls whether colors are
2394 The color_info configuration parameter controls whether colors are
2396 used for displaying object details (by things like %psource, %pfile or
2395 used for displaying object details (by things like %psource, %pfile or
2397 the '?' system). This function toggles this value with each call.
2396 the '?' system). This function toggles this value with each call.
2398
2397
2399 Note that unless you have a fairly recent pager (less works better
2398 Note that unless you have a fairly recent pager (less works better
2400 than more) in your system, using colored object information displays
2399 than more) in your system, using colored object information displays
2401 will not work properly. Test it and see."""
2400 will not work properly. Test it and see."""
2402
2401
2403 self.shell.rc.color_info = 1 - self.shell.rc.color_info
2402 self.shell.rc.color_info = 1 - self.shell.rc.color_info
2404 self.magic_colors(self.shell.rc.colors)
2403 self.magic_colors(self.shell.rc.colors)
2405 print 'Object introspection functions have now coloring:',
2404 print 'Object introspection functions have now coloring:',
2406 print ['OFF','ON'][self.shell.rc.color_info]
2405 print ['OFF','ON'][self.shell.rc.color_info]
2407
2406
2408 def magic_Pprint(self, parameter_s=''):
2407 def magic_Pprint(self, parameter_s=''):
2409 """Toggle pretty printing on/off."""
2408 """Toggle pretty printing on/off."""
2410
2409
2411 self.shell.rc.pprint = 1 - self.shell.rc.pprint
2410 self.shell.rc.pprint = 1 - self.shell.rc.pprint
2412 print 'Pretty printing has been turned', \
2411 print 'Pretty printing has been turned', \
2413 ['OFF','ON'][self.shell.rc.pprint]
2412 ['OFF','ON'][self.shell.rc.pprint]
2414
2413
2415 def magic_exit(self, parameter_s=''):
2414 def magic_exit(self, parameter_s=''):
2416 """Exit IPython, confirming if configured to do so.
2415 """Exit IPython, confirming if configured to do so.
2417
2416
2418 You can configure whether IPython asks for confirmation upon exit by
2417 You can configure whether IPython asks for confirmation upon exit by
2419 setting the confirm_exit flag in the ipythonrc file."""
2418 setting the confirm_exit flag in the ipythonrc file."""
2420
2419
2421 self.shell.exit()
2420 self.shell.exit()
2422
2421
2423 def magic_quit(self, parameter_s=''):
2422 def magic_quit(self, parameter_s=''):
2424 """Exit IPython, confirming if configured to do so (like %exit)"""
2423 """Exit IPython, confirming if configured to do so (like %exit)"""
2425
2424
2426 self.shell.exit()
2425 self.shell.exit()
2427
2426
2428 def magic_Exit(self, parameter_s=''):
2427 def magic_Exit(self, parameter_s=''):
2429 """Exit IPython without confirmation."""
2428 """Exit IPython without confirmation."""
2430
2429
2431 self.shell.exit_now = True
2430 self.shell.exit_now = True
2432
2431
2433 #......................................................................
2432 #......................................................................
2434 # Functions to implement unix shell-type things
2433 # Functions to implement unix shell-type things
2435
2434
2436 def magic_alias(self, parameter_s = ''):
2435 def magic_alias(self, parameter_s = ''):
2437 """Define an alias for a system command.
2436 """Define an alias for a system command.
2438
2437
2439 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2438 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2440
2439
2441 Then, typing 'alias_name params' will execute the system command 'cmd
2440 Then, typing 'alias_name params' will execute the system command 'cmd
2442 params' (from your underlying operating system).
2441 params' (from your underlying operating system).
2443
2442
2444 Aliases have lower precedence than magic functions and Python normal
2443 Aliases have lower precedence than magic functions and Python normal
2445 variables, so if 'foo' is both a Python variable and an alias, the
2444 variables, so if 'foo' is both a Python variable and an alias, the
2446 alias can not be executed until 'del foo' removes the Python variable.
2445 alias can not be executed until 'del foo' removes the Python variable.
2447
2446
2448 You can use the %l specifier in an alias definition to represent the
2447 You can use the %l specifier in an alias definition to represent the
2449 whole line when the alias is called. For example:
2448 whole line when the alias is called. For example:
2450
2449
2451 In [2]: alias all echo "Input in brackets: <%l>"\\
2450 In [2]: alias all echo "Input in brackets: <%l>"\\
2452 In [3]: all hello world\\
2451 In [3]: all hello world\\
2453 Input in brackets: <hello world>
2452 Input in brackets: <hello world>
2454
2453
2455 You can also define aliases with parameters using %s specifiers (one
2454 You can also define aliases with parameters using %s specifiers (one
2456 per parameter):
2455 per parameter):
2457
2456
2458 In [1]: alias parts echo first %s second %s\\
2457 In [1]: alias parts echo first %s second %s\\
2459 In [2]: %parts A B\\
2458 In [2]: %parts A B\\
2460 first A second B\\
2459 first A second B\\
2461 In [3]: %parts A\\
2460 In [3]: %parts A\\
2462 Incorrect number of arguments: 2 expected.\\
2461 Incorrect number of arguments: 2 expected.\\
2463 parts is an alias to: 'echo first %s second %s'
2462 parts is an alias to: 'echo first %s second %s'
2464
2463
2465 Note that %l and %s are mutually exclusive. You can only use one or
2464 Note that %l and %s are mutually exclusive. You can only use one or
2466 the other in your aliases.
2465 the other in your aliases.
2467
2466
2468 Aliases expand Python variables just like system calls using ! or !!
2467 Aliases expand Python variables just like system calls using ! or !!
2469 do: all expressions prefixed with '$' get expanded. For details of
2468 do: all expressions prefixed with '$' get expanded. For details of
2470 the semantic rules, see PEP-215:
2469 the semantic rules, see PEP-215:
2471 http://www.python.org/peps/pep-0215.html. This is the library used by
2470 http://www.python.org/peps/pep-0215.html. This is the library used by
2472 IPython for variable expansion. If you want to access a true shell
2471 IPython for variable expansion. If you want to access a true shell
2473 variable, an extra $ is necessary to prevent its expansion by IPython:
2472 variable, an extra $ is necessary to prevent its expansion by IPython:
2474
2473
2475 In [6]: alias show echo\\
2474 In [6]: alias show echo\\
2476 In [7]: PATH='A Python string'\\
2475 In [7]: PATH='A Python string'\\
2477 In [8]: show $PATH\\
2476 In [8]: show $PATH\\
2478 A Python string\\
2477 A Python string\\
2479 In [9]: show $$PATH\\
2478 In [9]: show $$PATH\\
2480 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2479 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2481
2480
2482 You can use the alias facility to acess all of $PATH. See the %rehash
2481 You can use the alias facility to acess all of $PATH. See the %rehash
2483 and %rehashx functions, which automatically create aliases for the
2482 and %rehashx functions, which automatically create aliases for the
2484 contents of your $PATH.
2483 contents of your $PATH.
2485
2484
2486 If called with no parameters, %alias prints the current alias table."""
2485 If called with no parameters, %alias prints the current alias table."""
2487
2486
2488 par = parameter_s.strip()
2487 par = parameter_s.strip()
2489 if not par:
2488 if not par:
2490 stored = self.db.get('stored_aliases', {} )
2489 stored = self.db.get('stored_aliases', {} )
2491 atab = self.shell.alias_table
2490 atab = self.shell.alias_table
2492 aliases = atab.keys()
2491 aliases = atab.keys()
2493 aliases.sort()
2492 aliases.sort()
2494 res = []
2493 res = []
2495 showlast = []
2494 showlast = []
2496 for alias in aliases:
2495 for alias in aliases:
2497 special = False
2496 special = False
2498 try:
2497 try:
2499 tgt = atab[alias][1]
2498 tgt = atab[alias][1]
2500 except (TypeError, AttributeError):
2499 except (TypeError, AttributeError):
2501 # unsubscriptable? probably a callable
2500 # unsubscriptable? probably a callable
2502 tgt = atab[alias]
2501 tgt = atab[alias]
2503 special = True
2502 special = True
2504 # 'interesting' aliases
2503 # 'interesting' aliases
2505 if (alias in stored or
2504 if (alias in stored or
2506 special or
2505 special or
2507 alias.lower() != os.path.splitext(tgt)[0].lower() or
2506 alias.lower() != os.path.splitext(tgt)[0].lower() or
2508 ' ' in tgt):
2507 ' ' in tgt):
2509 showlast.append((alias, tgt))
2508 showlast.append((alias, tgt))
2510 else:
2509 else:
2511 res.append((alias, tgt ))
2510 res.append((alias, tgt ))
2512
2511
2513 # show most interesting aliases last
2512 # show most interesting aliases last
2514 res.extend(showlast)
2513 res.extend(showlast)
2515 print "Total number of aliases:",len(aliases)
2514 print "Total number of aliases:",len(aliases)
2516 return res
2515 return res
2517 try:
2516 try:
2518 alias,cmd = par.split(None,1)
2517 alias,cmd = par.split(None,1)
2519 except:
2518 except:
2520 print OInspect.getdoc(self.magic_alias)
2519 print OInspect.getdoc(self.magic_alias)
2521 else:
2520 else:
2522 nargs = cmd.count('%s')
2521 nargs = cmd.count('%s')
2523 if nargs>0 and cmd.find('%l')>=0:
2522 if nargs>0 and cmd.find('%l')>=0:
2524 error('The %s and %l specifiers are mutually exclusive '
2523 error('The %s and %l specifiers are mutually exclusive '
2525 'in alias definitions.')
2524 'in alias definitions.')
2526 else: # all looks OK
2525 else: # all looks OK
2527 self.shell.alias_table[alias] = (nargs,cmd)
2526 self.shell.alias_table[alias] = (nargs,cmd)
2528 self.shell.alias_table_validate(verbose=0)
2527 self.shell.alias_table_validate(verbose=0)
2529 # end magic_alias
2528 # end magic_alias
2530
2529
2531 def magic_unalias(self, parameter_s = ''):
2530 def magic_unalias(self, parameter_s = ''):
2532 """Remove an alias"""
2531 """Remove an alias"""
2533
2532
2534 aname = parameter_s.strip()
2533 aname = parameter_s.strip()
2535 if aname in self.shell.alias_table:
2534 if aname in self.shell.alias_table:
2536 del self.shell.alias_table[aname]
2535 del self.shell.alias_table[aname]
2537 stored = self.db.get('stored_aliases', {} )
2536 stored = self.db.get('stored_aliases', {} )
2538 if aname in stored:
2537 if aname in stored:
2539 print "Removing %stored alias",aname
2538 print "Removing %stored alias",aname
2540 del stored[aname]
2539 del stored[aname]
2541 self.db['stored_aliases'] = stored
2540 self.db['stored_aliases'] = stored
2542
2541
2543
2542
2544 def magic_rehashx(self, parameter_s = ''):
2543 def magic_rehashx(self, parameter_s = ''):
2545 """Update the alias table with all executable files in $PATH.
2544 """Update the alias table with all executable files in $PATH.
2546
2545
2547 This version explicitly checks that every entry in $PATH is a file
2546 This version explicitly checks that every entry in $PATH is a file
2548 with execute access (os.X_OK), so it is much slower than %rehash.
2547 with execute access (os.X_OK), so it is much slower than %rehash.
2549
2548
2550 Under Windows, it checks executability as a match agains a
2549 Under Windows, it checks executability as a match agains a
2551 '|'-separated string of extensions, stored in the IPython config
2550 '|'-separated string of extensions, stored in the IPython config
2552 variable win_exec_ext. This defaults to 'exe|com|bat'.
2551 variable win_exec_ext. This defaults to 'exe|com|bat'.
2553
2552
2554 This function also resets the root module cache of module completer,
2553 This function also resets the root module cache of module completer,
2555 used on slow filesystems.
2554 used on slow filesystems.
2556 """
2555 """
2557
2556
2558
2557
2559 ip = self.api
2558 ip = self.api
2560
2559
2561 # for the benefit of module completer in ipy_completers.py
2560 # for the benefit of module completer in ipy_completers.py
2562 del ip.db['rootmodules']
2561 del ip.db['rootmodules']
2563
2562
2564 path = [os.path.abspath(os.path.expanduser(p)) for p in
2563 path = [os.path.abspath(os.path.expanduser(p)) for p in
2565 os.environ.get('PATH','').split(os.pathsep)]
2564 os.environ.get('PATH','').split(os.pathsep)]
2566 path = filter(os.path.isdir,path)
2565 path = filter(os.path.isdir,path)
2567
2566
2568 alias_table = self.shell.alias_table
2567 alias_table = self.shell.alias_table
2569 syscmdlist = []
2568 syscmdlist = []
2570 if os.name == 'posix':
2569 if os.name == 'posix':
2571 isexec = lambda fname:os.path.isfile(fname) and \
2570 isexec = lambda fname:os.path.isfile(fname) and \
2572 os.access(fname,os.X_OK)
2571 os.access(fname,os.X_OK)
2573 else:
2572 else:
2574
2573
2575 try:
2574 try:
2576 winext = os.environ['pathext'].replace(';','|').replace('.','')
2575 winext = os.environ['pathext'].replace(';','|').replace('.','')
2577 except KeyError:
2576 except KeyError:
2578 winext = 'exe|com|bat|py'
2577 winext = 'exe|com|bat|py'
2579 if 'py' not in winext:
2578 if 'py' not in winext:
2580 winext += '|py'
2579 winext += '|py'
2581 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2580 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2582 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2581 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2583 savedir = os.getcwd()
2582 savedir = os.getcwd()
2584 try:
2583 try:
2585 # write the whole loop for posix/Windows so we don't have an if in
2584 # write the whole loop for posix/Windows so we don't have an if in
2586 # the innermost part
2585 # the innermost part
2587 if os.name == 'posix':
2586 if os.name == 'posix':
2588 for pdir in path:
2587 for pdir in path:
2589 os.chdir(pdir)
2588 os.chdir(pdir)
2590 for ff in os.listdir(pdir):
2589 for ff in os.listdir(pdir):
2591 if isexec(ff) and ff not in self.shell.no_alias:
2590 if isexec(ff) and ff not in self.shell.no_alias:
2592 # each entry in the alias table must be (N,name),
2591 # each entry in the alias table must be (N,name),
2593 # where N is the number of positional arguments of the
2592 # where N is the number of positional arguments of the
2594 # alias.
2593 # alias.
2595 alias_table[ff] = (0,ff)
2594 alias_table[ff] = (0,ff)
2596 syscmdlist.append(ff)
2595 syscmdlist.append(ff)
2597 else:
2596 else:
2598 for pdir in path:
2597 for pdir in path:
2599 os.chdir(pdir)
2598 os.chdir(pdir)
2600 for ff in os.listdir(pdir):
2599 for ff in os.listdir(pdir):
2601 base, ext = os.path.splitext(ff)
2600 base, ext = os.path.splitext(ff)
2602 if isexec(ff) and base not in self.shell.no_alias:
2601 if isexec(ff) and base not in self.shell.no_alias:
2603 if ext.lower() == '.exe':
2602 if ext.lower() == '.exe':
2604 ff = base
2603 ff = base
2605 alias_table[base.lower()] = (0,ff)
2604 alias_table[base.lower()] = (0,ff)
2606 syscmdlist.append(ff)
2605 syscmdlist.append(ff)
2607 # Make sure the alias table doesn't contain keywords or builtins
2606 # Make sure the alias table doesn't contain keywords or builtins
2608 self.shell.alias_table_validate()
2607 self.shell.alias_table_validate()
2609 # Call again init_auto_alias() so we get 'rm -i' and other
2608 # Call again init_auto_alias() so we get 'rm -i' and other
2610 # modified aliases since %rehashx will probably clobber them
2609 # modified aliases since %rehashx will probably clobber them
2611
2610
2612 # no, we don't want them. if %rehashx clobbers them, good,
2611 # no, we don't want them. if %rehashx clobbers them, good,
2613 # we'll probably get better versions
2612 # we'll probably get better versions
2614 # self.shell.init_auto_alias()
2613 # self.shell.init_auto_alias()
2615 db = ip.db
2614 db = ip.db
2616 db['syscmdlist'] = syscmdlist
2615 db['syscmdlist'] = syscmdlist
2617 finally:
2616 finally:
2618 os.chdir(savedir)
2617 os.chdir(savedir)
2619
2618
2620 def magic_pwd(self, parameter_s = ''):
2619 def magic_pwd(self, parameter_s = ''):
2621 """Return the current working directory path."""
2620 """Return the current working directory path."""
2622 return os.getcwd()
2621 return os.getcwd()
2623
2622
2624 def magic_cd(self, parameter_s=''):
2623 def magic_cd(self, parameter_s=''):
2625 """Change the current working directory.
2624 """Change the current working directory.
2626
2625
2627 This command automatically maintains an internal list of directories
2626 This command automatically maintains an internal list of directories
2628 you visit during your IPython session, in the variable _dh. The
2627 you visit during your IPython session, in the variable _dh. The
2629 command %dhist shows this history nicely formatted. You can also
2628 command %dhist shows this history nicely formatted. You can also
2630 do 'cd -<tab>' to see directory history conveniently.
2629 do 'cd -<tab>' to see directory history conveniently.
2631
2630
2632 Usage:
2631 Usage:
2633
2632
2634 cd 'dir': changes to directory 'dir'.
2633 cd 'dir': changes to directory 'dir'.
2635
2634
2636 cd -: changes to the last visited directory.
2635 cd -: changes to the last visited directory.
2637
2636
2638 cd -<n>: changes to the n-th directory in the directory history.
2637 cd -<n>: changes to the n-th directory in the directory history.
2639
2638
2640 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2639 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2641 (note: cd <bookmark_name> is enough if there is no
2640 (note: cd <bookmark_name> is enough if there is no
2642 directory <bookmark_name>, but a bookmark with the name exists.)
2641 directory <bookmark_name>, but a bookmark with the name exists.)
2643 'cd -b <tab>' allows you to tab-complete bookmark names.
2642 'cd -b <tab>' allows you to tab-complete bookmark names.
2644
2643
2645 Options:
2644 Options:
2646
2645
2647 -q: quiet. Do not print the working directory after the cd command is
2646 -q: quiet. Do not print the working directory after the cd command is
2648 executed. By default IPython's cd command does print this directory,
2647 executed. By default IPython's cd command does print this directory,
2649 since the default prompts do not display path information.
2648 since the default prompts do not display path information.
2650
2649
2651 Note that !cd doesn't work for this purpose because the shell where
2650 Note that !cd doesn't work for this purpose because the shell where
2652 !command runs is immediately discarded after executing 'command'."""
2651 !command runs is immediately discarded after executing 'command'."""
2653
2652
2654 parameter_s = parameter_s.strip()
2653 parameter_s = parameter_s.strip()
2655 #bkms = self.shell.persist.get("bookmarks",{})
2654 #bkms = self.shell.persist.get("bookmarks",{})
2656
2655
2657 numcd = re.match(r'(-)(\d+)$',parameter_s)
2656 numcd = re.match(r'(-)(\d+)$',parameter_s)
2658 # jump in directory history by number
2657 # jump in directory history by number
2659 if numcd:
2658 if numcd:
2660 nn = int(numcd.group(2))
2659 nn = int(numcd.group(2))
2661 try:
2660 try:
2662 ps = self.shell.user_ns['_dh'][nn]
2661 ps = self.shell.user_ns['_dh'][nn]
2663 except IndexError:
2662 except IndexError:
2664 print 'The requested directory does not exist in history.'
2663 print 'The requested directory does not exist in history.'
2665 return
2664 return
2666 else:
2665 else:
2667 opts = {}
2666 opts = {}
2668 else:
2667 else:
2669 #turn all non-space-escaping backslashes to slashes,
2668 #turn all non-space-escaping backslashes to slashes,
2670 # for c:\windows\directory\names\
2669 # for c:\windows\directory\names\
2671 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2670 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2672 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2671 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2673 # jump to previous
2672 # jump to previous
2674 if ps == '-':
2673 if ps == '-':
2675 try:
2674 try:
2676 ps = self.shell.user_ns['_dh'][-2]
2675 ps = self.shell.user_ns['_dh'][-2]
2677 except IndexError:
2676 except IndexError:
2678 raise UsageError('%cd -: No previous directory to change to.')
2677 raise UsageError('%cd -: No previous directory to change to.')
2679 # jump to bookmark if needed
2678 # jump to bookmark if needed
2680 else:
2679 else:
2681 if not os.path.isdir(ps) or opts.has_key('b'):
2680 if not os.path.isdir(ps) or opts.has_key('b'):
2682 bkms = self.db.get('bookmarks', {})
2681 bkms = self.db.get('bookmarks', {})
2683
2682
2684 if bkms.has_key(ps):
2683 if bkms.has_key(ps):
2685 target = bkms[ps]
2684 target = bkms[ps]
2686 print '(bookmark:%s) -> %s' % (ps,target)
2685 print '(bookmark:%s) -> %s' % (ps,target)
2687 ps = target
2686 ps = target
2688 else:
2687 else:
2689 if opts.has_key('b'):
2688 if opts.has_key('b'):
2690 raise UsageError("Bookmark '%s' not found. "
2689 raise UsageError("Bookmark '%s' not found. "
2691 "Use '%%bookmark -l' to see your bookmarks." % ps)
2690 "Use '%%bookmark -l' to see your bookmarks." % ps)
2692
2691
2693 # at this point ps should point to the target dir
2692 # at this point ps should point to the target dir
2694 if ps:
2693 if ps:
2695 try:
2694 try:
2696 os.chdir(os.path.expanduser(ps))
2695 os.chdir(os.path.expanduser(ps))
2697 if self.shell.rc.term_title:
2696 if self.shell.rc.term_title:
2698 #print 'set term title:',self.shell.rc.term_title # dbg
2697 #print 'set term title:',self.shell.rc.term_title # dbg
2699 ttitle = 'IPy ' + abbrev_cwd()
2698 ttitle = 'IPy ' + abbrev_cwd()
2700 platutils.set_term_title(ttitle)
2699 platutils.set_term_title(ttitle)
2701 except OSError:
2700 except OSError:
2702 print sys.exc_info()[1]
2701 print sys.exc_info()[1]
2703 else:
2702 else:
2704 cwd = os.getcwd()
2703 cwd = os.getcwd()
2705 dhist = self.shell.user_ns['_dh']
2704 dhist = self.shell.user_ns['_dh']
2706 dhist.append(cwd)
2705 dhist.append(cwd)
2707 self.db['dhist'] = compress_dhist(dhist)[-100:]
2706 self.db['dhist'] = compress_dhist(dhist)[-100:]
2708
2707
2709 else:
2708 else:
2710 os.chdir(self.shell.home_dir)
2709 os.chdir(self.shell.home_dir)
2711 if self.shell.rc.term_title:
2710 if self.shell.rc.term_title:
2712 platutils.set_term_title("IPy ~")
2711 platutils.set_term_title("IPy ~")
2713 cwd = os.getcwd()
2712 cwd = os.getcwd()
2714 dhist = self.shell.user_ns['_dh']
2713 dhist = self.shell.user_ns['_dh']
2715 dhist.append(cwd)
2714 dhist.append(cwd)
2716 self.db['dhist'] = compress_dhist(dhist)[-100:]
2715 self.db['dhist'] = compress_dhist(dhist)[-100:]
2717 if not 'q' in opts and self.shell.user_ns['_dh']:
2716 if not 'q' in opts and self.shell.user_ns['_dh']:
2718 print self.shell.user_ns['_dh'][-1]
2717 print self.shell.user_ns['_dh'][-1]
2719
2718
2720
2719
2721 def magic_env(self, parameter_s=''):
2720 def magic_env(self, parameter_s=''):
2722 """List environment variables."""
2721 """List environment variables."""
2723
2722
2724 return os.environ.data
2723 return os.environ.data
2725
2724
2726 def magic_pushd(self, parameter_s=''):
2725 def magic_pushd(self, parameter_s=''):
2727 """Place the current dir on stack and change directory.
2726 """Place the current dir on stack and change directory.
2728
2727
2729 Usage:\\
2728 Usage:\\
2730 %pushd ['dirname']
2729 %pushd ['dirname']
2731 """
2730 """
2732
2731
2733 dir_s = self.shell.dir_stack
2732 dir_s = self.shell.dir_stack
2734 tgt = os.path.expanduser(parameter_s)
2733 tgt = os.path.expanduser(parameter_s)
2735 cwd = os.getcwd().replace(self.home_dir,'~')
2734 cwd = os.getcwd().replace(self.home_dir,'~')
2736 if tgt:
2735 if tgt:
2737 self.magic_cd(parameter_s)
2736 self.magic_cd(parameter_s)
2738 dir_s.insert(0,cwd)
2737 dir_s.insert(0,cwd)
2739 return self.magic_dirs()
2738 return self.magic_dirs()
2740
2739
2741 def magic_popd(self, parameter_s=''):
2740 def magic_popd(self, parameter_s=''):
2742 """Change to directory popped off the top of the stack.
2741 """Change to directory popped off the top of the stack.
2743 """
2742 """
2744 if not self.shell.dir_stack:
2743 if not self.shell.dir_stack:
2745 raise UsageError("%popd on empty stack")
2744 raise UsageError("%popd on empty stack")
2746 top = self.shell.dir_stack.pop(0)
2745 top = self.shell.dir_stack.pop(0)
2747 self.magic_cd(top)
2746 self.magic_cd(top)
2748 print "popd ->",top
2747 print "popd ->",top
2749
2748
2750 def magic_dirs(self, parameter_s=''):
2749 def magic_dirs(self, parameter_s=''):
2751 """Return the current directory stack."""
2750 """Return the current directory stack."""
2752
2751
2753 return self.shell.dir_stack
2752 return self.shell.dir_stack
2754
2753
2755 def magic_dhist(self, parameter_s=''):
2754 def magic_dhist(self, parameter_s=''):
2756 """Print your history of visited directories.
2755 """Print your history of visited directories.
2757
2756
2758 %dhist -> print full history\\
2757 %dhist -> print full history\\
2759 %dhist n -> print last n entries only\\
2758 %dhist n -> print last n entries only\\
2760 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2759 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2761
2760
2762 This history is automatically maintained by the %cd command, and
2761 This history is automatically maintained by the %cd command, and
2763 always available as the global list variable _dh. You can use %cd -<n>
2762 always available as the global list variable _dh. You can use %cd -<n>
2764 to go to directory number <n>.
2763 to go to directory number <n>.
2765
2764
2766 Note that most of time, you should view directory history by entering
2765 Note that most of time, you should view directory history by entering
2767 cd -<TAB>.
2766 cd -<TAB>.
2768
2767
2769 """
2768 """
2770
2769
2771 dh = self.shell.user_ns['_dh']
2770 dh = self.shell.user_ns['_dh']
2772 if parameter_s:
2771 if parameter_s:
2773 try:
2772 try:
2774 args = map(int,parameter_s.split())
2773 args = map(int,parameter_s.split())
2775 except:
2774 except:
2776 self.arg_err(Magic.magic_dhist)
2775 self.arg_err(Magic.magic_dhist)
2777 return
2776 return
2778 if len(args) == 1:
2777 if len(args) == 1:
2779 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2778 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2780 elif len(args) == 2:
2779 elif len(args) == 2:
2781 ini,fin = args
2780 ini,fin = args
2782 else:
2781 else:
2783 self.arg_err(Magic.magic_dhist)
2782 self.arg_err(Magic.magic_dhist)
2784 return
2783 return
2785 else:
2784 else:
2786 ini,fin = 0,len(dh)
2785 ini,fin = 0,len(dh)
2787 nlprint(dh,
2786 nlprint(dh,
2788 header = 'Directory history (kept in _dh)',
2787 header = 'Directory history (kept in _dh)',
2789 start=ini,stop=fin)
2788 start=ini,stop=fin)
2790
2789
2791
2790
2792 def magic_sc(self, parameter_s=''):
2791 def magic_sc(self, parameter_s=''):
2793 """Shell capture - execute a shell command and capture its output.
2792 """Shell capture - execute a shell command and capture its output.
2794
2793
2795 DEPRECATED. Suboptimal, retained for backwards compatibility.
2794 DEPRECATED. Suboptimal, retained for backwards compatibility.
2796
2795
2797 You should use the form 'var = !command' instead. Example:
2796 You should use the form 'var = !command' instead. Example:
2798
2797
2799 "%sc -l myfiles = ls ~" should now be written as
2798 "%sc -l myfiles = ls ~" should now be written as
2800
2799
2801 "myfiles = !ls ~"
2800 "myfiles = !ls ~"
2802
2801
2803 myfiles.s, myfiles.l and myfiles.n still apply as documented
2802 myfiles.s, myfiles.l and myfiles.n still apply as documented
2804 below.
2803 below.
2805
2804
2806 --
2805 --
2807 %sc [options] varname=command
2806 %sc [options] varname=command
2808
2807
2809 IPython will run the given command using commands.getoutput(), and
2808 IPython will run the given command using commands.getoutput(), and
2810 will then update the user's interactive namespace with a variable
2809 will then update the user's interactive namespace with a variable
2811 called varname, containing the value of the call. Your command can
2810 called varname, containing the value of the call. Your command can
2812 contain shell wildcards, pipes, etc.
2811 contain shell wildcards, pipes, etc.
2813
2812
2814 The '=' sign in the syntax is mandatory, and the variable name you
2813 The '=' sign in the syntax is mandatory, and the variable name you
2815 supply must follow Python's standard conventions for valid names.
2814 supply must follow Python's standard conventions for valid names.
2816
2815
2817 (A special format without variable name exists for internal use)
2816 (A special format without variable name exists for internal use)
2818
2817
2819 Options:
2818 Options:
2820
2819
2821 -l: list output. Split the output on newlines into a list before
2820 -l: list output. Split the output on newlines into a list before
2822 assigning it to the given variable. By default the output is stored
2821 assigning it to the given variable. By default the output is stored
2823 as a single string.
2822 as a single string.
2824
2823
2825 -v: verbose. Print the contents of the variable.
2824 -v: verbose. Print the contents of the variable.
2826
2825
2827 In most cases you should not need to split as a list, because the
2826 In most cases you should not need to split as a list, because the
2828 returned value is a special type of string which can automatically
2827 returned value is a special type of string which can automatically
2829 provide its contents either as a list (split on newlines) or as a
2828 provide its contents either as a list (split on newlines) or as a
2830 space-separated string. These are convenient, respectively, either
2829 space-separated string. These are convenient, respectively, either
2831 for sequential processing or to be passed to a shell command.
2830 for sequential processing or to be passed to a shell command.
2832
2831
2833 For example:
2832 For example:
2834
2833
2835 # Capture into variable a
2834 # Capture into variable a
2836 In [9]: sc a=ls *py
2835 In [9]: sc a=ls *py
2837
2836
2838 # a is a string with embedded newlines
2837 # a is a string with embedded newlines
2839 In [10]: a
2838 In [10]: a
2840 Out[10]: 'setup.py\nwin32_manual_post_install.py'
2839 Out[10]: 'setup.py\nwin32_manual_post_install.py'
2841
2840
2842 # which can be seen as a list:
2841 # which can be seen as a list:
2843 In [11]: a.l
2842 In [11]: a.l
2844 Out[11]: ['setup.py', 'win32_manual_post_install.py']
2843 Out[11]: ['setup.py', 'win32_manual_post_install.py']
2845
2844
2846 # or as a whitespace-separated string:
2845 # or as a whitespace-separated string:
2847 In [12]: a.s
2846 In [12]: a.s
2848 Out[12]: 'setup.py win32_manual_post_install.py'
2847 Out[12]: 'setup.py win32_manual_post_install.py'
2849
2848
2850 # a.s is useful to pass as a single command line:
2849 # a.s is useful to pass as a single command line:
2851 In [13]: !wc -l $a.s
2850 In [13]: !wc -l $a.s
2852 146 setup.py
2851 146 setup.py
2853 130 win32_manual_post_install.py
2852 130 win32_manual_post_install.py
2854 276 total
2853 276 total
2855
2854
2856 # while the list form is useful to loop over:
2855 # while the list form is useful to loop over:
2857 In [14]: for f in a.l:
2856 In [14]: for f in a.l:
2858 ....: !wc -l $f
2857 ....: !wc -l $f
2859 ....:
2858 ....:
2860 146 setup.py
2859 146 setup.py
2861 130 win32_manual_post_install.py
2860 130 win32_manual_post_install.py
2862
2861
2863 Similiarly, the lists returned by the -l option are also special, in
2862 Similiarly, the lists returned by the -l option are also special, in
2864 the sense that you can equally invoke the .s attribute on them to
2863 the sense that you can equally invoke the .s attribute on them to
2865 automatically get a whitespace-separated string from their contents:
2864 automatically get a whitespace-separated string from their contents:
2866
2865
2867 In [1]: sc -l b=ls *py
2866 In [1]: sc -l b=ls *py
2868
2867
2869 In [2]: b
2868 In [2]: b
2870 Out[2]: ['setup.py', 'win32_manual_post_install.py']
2869 Out[2]: ['setup.py', 'win32_manual_post_install.py']
2871
2870
2872 In [3]: b.s
2871 In [3]: b.s
2873 Out[3]: 'setup.py win32_manual_post_install.py'
2872 Out[3]: 'setup.py win32_manual_post_install.py'
2874
2873
2875 In summary, both the lists and strings used for ouptut capture have
2874 In summary, both the lists and strings used for ouptut capture have
2876 the following special attributes:
2875 the following special attributes:
2877
2876
2878 .l (or .list) : value as list.
2877 .l (or .list) : value as list.
2879 .n (or .nlstr): value as newline-separated string.
2878 .n (or .nlstr): value as newline-separated string.
2880 .s (or .spstr): value as space-separated string.
2879 .s (or .spstr): value as space-separated string.
2881 """
2880 """
2882
2881
2883 opts,args = self.parse_options(parameter_s,'lv')
2882 opts,args = self.parse_options(parameter_s,'lv')
2884 # Try to get a variable name and command to run
2883 # Try to get a variable name and command to run
2885 try:
2884 try:
2886 # the variable name must be obtained from the parse_options
2885 # the variable name must be obtained from the parse_options
2887 # output, which uses shlex.split to strip options out.
2886 # output, which uses shlex.split to strip options out.
2888 var,_ = args.split('=',1)
2887 var,_ = args.split('=',1)
2889 var = var.strip()
2888 var = var.strip()
2890 # But the the command has to be extracted from the original input
2889 # But the the command has to be extracted from the original input
2891 # parameter_s, not on what parse_options returns, to avoid the
2890 # parameter_s, not on what parse_options returns, to avoid the
2892 # quote stripping which shlex.split performs on it.
2891 # quote stripping which shlex.split performs on it.
2893 _,cmd = parameter_s.split('=',1)
2892 _,cmd = parameter_s.split('=',1)
2894 except ValueError:
2893 except ValueError:
2895 var,cmd = '',''
2894 var,cmd = '',''
2896 # If all looks ok, proceed
2895 # If all looks ok, proceed
2897 out,err = self.shell.getoutputerror(cmd)
2896 out,err = self.shell.getoutputerror(cmd)
2898 if err:
2897 if err:
2899 print >> Term.cerr,err
2898 print >> Term.cerr,err
2900 if opts.has_key('l'):
2899 if opts.has_key('l'):
2901 out = SList(out.split('\n'))
2900 out = SList(out.split('\n'))
2902 else:
2901 else:
2903 out = LSString(out)
2902 out = LSString(out)
2904 if opts.has_key('v'):
2903 if opts.has_key('v'):
2905 print '%s ==\n%s' % (var,pformat(out))
2904 print '%s ==\n%s' % (var,pformat(out))
2906 if var:
2905 if var:
2907 self.shell.user_ns.update({var:out})
2906 self.shell.user_ns.update({var:out})
2908 else:
2907 else:
2909 return out
2908 return out
2910
2909
2911 def magic_sx(self, parameter_s=''):
2910 def magic_sx(self, parameter_s=''):
2912 """Shell execute - run a shell command and capture its output.
2911 """Shell execute - run a shell command and capture its output.
2913
2912
2914 %sx command
2913 %sx command
2915
2914
2916 IPython will run the given command using commands.getoutput(), and
2915 IPython will run the given command using commands.getoutput(), and
2917 return the result formatted as a list (split on '\\n'). Since the
2916 return the result formatted as a list (split on '\\n'). Since the
2918 output is _returned_, it will be stored in ipython's regular output
2917 output is _returned_, it will be stored in ipython's regular output
2919 cache Out[N] and in the '_N' automatic variables.
2918 cache Out[N] and in the '_N' automatic variables.
2920
2919
2921 Notes:
2920 Notes:
2922
2921
2923 1) If an input line begins with '!!', then %sx is automatically
2922 1) If an input line begins with '!!', then %sx is automatically
2924 invoked. That is, while:
2923 invoked. That is, while:
2925 !ls
2924 !ls
2926 causes ipython to simply issue system('ls'), typing
2925 causes ipython to simply issue system('ls'), typing
2927 !!ls
2926 !!ls
2928 is a shorthand equivalent to:
2927 is a shorthand equivalent to:
2929 %sx ls
2928 %sx ls
2930
2929
2931 2) %sx differs from %sc in that %sx automatically splits into a list,
2930 2) %sx differs from %sc in that %sx automatically splits into a list,
2932 like '%sc -l'. The reason for this is to make it as easy as possible
2931 like '%sc -l'. The reason for this is to make it as easy as possible
2933 to process line-oriented shell output via further python commands.
2932 to process line-oriented shell output via further python commands.
2934 %sc is meant to provide much finer control, but requires more
2933 %sc is meant to provide much finer control, but requires more
2935 typing.
2934 typing.
2936
2935
2937 3) Just like %sc -l, this is a list with special attributes:
2936 3) Just like %sc -l, this is a list with special attributes:
2938
2937
2939 .l (or .list) : value as list.
2938 .l (or .list) : value as list.
2940 .n (or .nlstr): value as newline-separated string.
2939 .n (or .nlstr): value as newline-separated string.
2941 .s (or .spstr): value as whitespace-separated string.
2940 .s (or .spstr): value as whitespace-separated string.
2942
2941
2943 This is very useful when trying to use such lists as arguments to
2942 This is very useful when trying to use such lists as arguments to
2944 system commands."""
2943 system commands."""
2945
2944
2946 if parameter_s:
2945 if parameter_s:
2947 out,err = self.shell.getoutputerror(parameter_s)
2946 out,err = self.shell.getoutputerror(parameter_s)
2948 if err:
2947 if err:
2949 print >> Term.cerr,err
2948 print >> Term.cerr,err
2950 return SList(out.split('\n'))
2949 return SList(out.split('\n'))
2951
2950
2952 def magic_bg(self, parameter_s=''):
2951 def magic_bg(self, parameter_s=''):
2953 """Run a job in the background, in a separate thread.
2952 """Run a job in the background, in a separate thread.
2954
2953
2955 For example,
2954 For example,
2956
2955
2957 %bg myfunc(x,y,z=1)
2956 %bg myfunc(x,y,z=1)
2958
2957
2959 will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
2958 will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
2960 execution starts, a message will be printed indicating the job
2959 execution starts, a message will be printed indicating the job
2961 number. If your job number is 5, you can use
2960 number. If your job number is 5, you can use
2962
2961
2963 myvar = jobs.result(5) or myvar = jobs[5].result
2962 myvar = jobs.result(5) or myvar = jobs[5].result
2964
2963
2965 to assign this result to variable 'myvar'.
2964 to assign this result to variable 'myvar'.
2966
2965
2967 IPython has a job manager, accessible via the 'jobs' object. You can
2966 IPython has a job manager, accessible via the 'jobs' object. You can
2968 type jobs? to get more information about it, and use jobs.<TAB> to see
2967 type jobs? to get more information about it, and use jobs.<TAB> to see
2969 its attributes. All attributes not starting with an underscore are
2968 its attributes. All attributes not starting with an underscore are
2970 meant for public use.
2969 meant for public use.
2971
2970
2972 In particular, look at the jobs.new() method, which is used to create
2971 In particular, look at the jobs.new() method, which is used to create
2973 new jobs. This magic %bg function is just a convenience wrapper
2972 new jobs. This magic %bg function is just a convenience wrapper
2974 around jobs.new(), for expression-based jobs. If you want to create a
2973 around jobs.new(), for expression-based jobs. If you want to create a
2975 new job with an explicit function object and arguments, you must call
2974 new job with an explicit function object and arguments, you must call
2976 jobs.new() directly.
2975 jobs.new() directly.
2977
2976
2978 The jobs.new docstring also describes in detail several important
2977 The jobs.new docstring also describes in detail several important
2979 caveats associated with a thread-based model for background job
2978 caveats associated with a thread-based model for background job
2980 execution. Type jobs.new? for details.
2979 execution. Type jobs.new? for details.
2981
2980
2982 You can check the status of all jobs with jobs.status().
2981 You can check the status of all jobs with jobs.status().
2983
2982
2984 The jobs variable is set by IPython into the Python builtin namespace.
2983 The jobs variable is set by IPython into the Python builtin namespace.
2985 If you ever declare a variable named 'jobs', you will shadow this
2984 If you ever declare a variable named 'jobs', you will shadow this
2986 name. You can either delete your global jobs variable to regain
2985 name. You can either delete your global jobs variable to regain
2987 access to the job manager, or make a new name and assign it manually
2986 access to the job manager, or make a new name and assign it manually
2988 to the manager (stored in IPython's namespace). For example, to
2987 to the manager (stored in IPython's namespace). For example, to
2989 assign the job manager to the Jobs name, use:
2988 assign the job manager to the Jobs name, use:
2990
2989
2991 Jobs = __builtins__.jobs"""
2990 Jobs = __builtins__.jobs"""
2992
2991
2993 self.shell.jobs.new(parameter_s,self.shell.user_ns)
2992 self.shell.jobs.new(parameter_s,self.shell.user_ns)
2994
2993
2995 def magic_r(self, parameter_s=''):
2994 def magic_r(self, parameter_s=''):
2996 """Repeat previous input.
2995 """Repeat previous input.
2997
2996
2998 Note: Consider using the more powerfull %rep instead!
2997 Note: Consider using the more powerfull %rep instead!
2999
2998
3000 If given an argument, repeats the previous command which starts with
2999 If given an argument, repeats the previous command which starts with
3001 the same string, otherwise it just repeats the previous input.
3000 the same string, otherwise it just repeats the previous input.
3002
3001
3003 Shell escaped commands (with ! as first character) are not recognized
3002 Shell escaped commands (with ! as first character) are not recognized
3004 by this system, only pure python code and magic commands.
3003 by this system, only pure python code and magic commands.
3005 """
3004 """
3006
3005
3007 start = parameter_s.strip()
3006 start = parameter_s.strip()
3008 esc_magic = self.shell.ESC_MAGIC
3007 esc_magic = self.shell.ESC_MAGIC
3009 # Identify magic commands even if automagic is on (which means
3008 # Identify magic commands even if automagic is on (which means
3010 # the in-memory version is different from that typed by the user).
3009 # the in-memory version is different from that typed by the user).
3011 if self.shell.rc.automagic:
3010 if self.shell.rc.automagic:
3012 start_magic = esc_magic+start
3011 start_magic = esc_magic+start
3013 else:
3012 else:
3014 start_magic = start
3013 start_magic = start
3015 # Look through the input history in reverse
3014 # Look through the input history in reverse
3016 for n in range(len(self.shell.input_hist)-2,0,-1):
3015 for n in range(len(self.shell.input_hist)-2,0,-1):
3017 input = self.shell.input_hist[n]
3016 input = self.shell.input_hist[n]
3018 # skip plain 'r' lines so we don't recurse to infinity
3017 # skip plain 'r' lines so we don't recurse to infinity
3019 if input != '_ip.magic("r")\n' and \
3018 if input != '_ip.magic("r")\n' and \
3020 (input.startswith(start) or input.startswith(start_magic)):
3019 (input.startswith(start) or input.startswith(start_magic)):
3021 #print 'match',`input` # dbg
3020 #print 'match',`input` # dbg
3022 print 'Executing:',input,
3021 print 'Executing:',input,
3023 self.shell.runlines(input)
3022 self.shell.runlines(input)
3024 return
3023 return
3025 print 'No previous input matching `%s` found.' % start
3024 print 'No previous input matching `%s` found.' % start
3026
3025
3027
3026
3028 def magic_bookmark(self, parameter_s=''):
3027 def magic_bookmark(self, parameter_s=''):
3029 """Manage IPython's bookmark system.
3028 """Manage IPython's bookmark system.
3030
3029
3031 %bookmark <name> - set bookmark to current dir
3030 %bookmark <name> - set bookmark to current dir
3032 %bookmark <name> <dir> - set bookmark to <dir>
3031 %bookmark <name> <dir> - set bookmark to <dir>
3033 %bookmark -l - list all bookmarks
3032 %bookmark -l - list all bookmarks
3034 %bookmark -d <name> - remove bookmark
3033 %bookmark -d <name> - remove bookmark
3035 %bookmark -r - remove all bookmarks
3034 %bookmark -r - remove all bookmarks
3036
3035
3037 You can later on access a bookmarked folder with:
3036 You can later on access a bookmarked folder with:
3038 %cd -b <name>
3037 %cd -b <name>
3039 or simply '%cd <name>' if there is no directory called <name> AND
3038 or simply '%cd <name>' if there is no directory called <name> AND
3040 there is such a bookmark defined.
3039 there is such a bookmark defined.
3041
3040
3042 Your bookmarks persist through IPython sessions, but they are
3041 Your bookmarks persist through IPython sessions, but they are
3043 associated with each profile."""
3042 associated with each profile."""
3044
3043
3045 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3044 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3046 if len(args) > 2:
3045 if len(args) > 2:
3047 raise UsageError("%bookmark: too many arguments")
3046 raise UsageError("%bookmark: too many arguments")
3048
3047
3049 bkms = self.db.get('bookmarks',{})
3048 bkms = self.db.get('bookmarks',{})
3050
3049
3051 if opts.has_key('d'):
3050 if opts.has_key('d'):
3052 try:
3051 try:
3053 todel = args[0]
3052 todel = args[0]
3054 except IndexError:
3053 except IndexError:
3055 raise UsageError(
3054 raise UsageError(
3056 "%bookmark -d: must provide a bookmark to delete")
3055 "%bookmark -d: must provide a bookmark to delete")
3057 else:
3056 else:
3058 try:
3057 try:
3059 del bkms[todel]
3058 del bkms[todel]
3060 except KeyError:
3059 except KeyError:
3061 raise UsageError(
3060 raise UsageError(
3062 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3061 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3063
3062
3064 elif opts.has_key('r'):
3063 elif opts.has_key('r'):
3065 bkms = {}
3064 bkms = {}
3066 elif opts.has_key('l'):
3065 elif opts.has_key('l'):
3067 bks = bkms.keys()
3066 bks = bkms.keys()
3068 bks.sort()
3067 bks.sort()
3069 if bks:
3068 if bks:
3070 size = max(map(len,bks))
3069 size = max(map(len,bks))
3071 else:
3070 else:
3072 size = 0
3071 size = 0
3073 fmt = '%-'+str(size)+'s -> %s'
3072 fmt = '%-'+str(size)+'s -> %s'
3074 print 'Current bookmarks:'
3073 print 'Current bookmarks:'
3075 for bk in bks:
3074 for bk in bks:
3076 print fmt % (bk,bkms[bk])
3075 print fmt % (bk,bkms[bk])
3077 else:
3076 else:
3078 if not args:
3077 if not args:
3079 raise UsageError("%bookmark: You must specify the bookmark name")
3078 raise UsageError("%bookmark: You must specify the bookmark name")
3080 elif len(args)==1:
3079 elif len(args)==1:
3081 bkms[args[0]] = os.getcwd()
3080 bkms[args[0]] = os.getcwd()
3082 elif len(args)==2:
3081 elif len(args)==2:
3083 bkms[args[0]] = args[1]
3082 bkms[args[0]] = args[1]
3084 self.db['bookmarks'] = bkms
3083 self.db['bookmarks'] = bkms
3085
3084
3086 def magic_pycat(self, parameter_s=''):
3085 def magic_pycat(self, parameter_s=''):
3087 """Show a syntax-highlighted file through a pager.
3086 """Show a syntax-highlighted file through a pager.
3088
3087
3089 This magic is similar to the cat utility, but it will assume the file
3088 This magic is similar to the cat utility, but it will assume the file
3090 to be Python source and will show it with syntax highlighting. """
3089 to be Python source and will show it with syntax highlighting. """
3091
3090
3092 try:
3091 try:
3093 filename = get_py_filename(parameter_s)
3092 filename = get_py_filename(parameter_s)
3094 cont = file_read(filename)
3093 cont = file_read(filename)
3095 except IOError:
3094 except IOError:
3096 try:
3095 try:
3097 cont = eval(parameter_s,self.user_ns)
3096 cont = eval(parameter_s,self.user_ns)
3098 except NameError:
3097 except NameError:
3099 cont = None
3098 cont = None
3100 if cont is None:
3099 if cont is None:
3101 print "Error: no such file or variable"
3100 print "Error: no such file or variable"
3102 return
3101 return
3103
3102
3104 page(self.shell.pycolorize(cont),
3103 page(self.shell.pycolorize(cont),
3105 screen_lines=self.shell.rc.screen_length)
3104 screen_lines=self.shell.rc.screen_length)
3106
3105
3107 def magic_cpaste(self, parameter_s=''):
3106 def magic_cpaste(self, parameter_s=''):
3108 """Allows you to paste & execute a pre-formatted code block from clipboard
3107 """Allows you to paste & execute a pre-formatted code block from clipboard
3109
3108
3110 You must terminate the block with '--' (two minus-signs) alone on the
3109 You must terminate the block with '--' (two minus-signs) alone on the
3111 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
3110 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
3112 is the new sentinel for this operation)
3111 is the new sentinel for this operation)
3113
3112
3114 The block is dedented prior to execution to enable execution of method
3113 The block is dedented prior to execution to enable execution of method
3115 definitions. '>' and '+' characters at the beginning of a line are
3114 definitions. '>' and '+' characters at the beginning of a line are
3116 ignored, to allow pasting directly from e-mails or diff files. The
3115 ignored, to allow pasting directly from e-mails or diff files. The
3117 executed block is also assigned to variable named 'pasted_block' for
3116 executed block is also assigned to variable named 'pasted_block' for
3118 later editing with '%edit pasted_block'.
3117 later editing with '%edit pasted_block'.
3119
3118
3120 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
3119 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
3121 This assigns the pasted block to variable 'foo' as string, without
3120 This assigns the pasted block to variable 'foo' as string, without
3122 dedenting or executing it.
3121 dedenting or executing it.
3123
3122
3124 Do not be alarmed by garbled output on Windows (it's a readline bug).
3123 Do not be alarmed by garbled output on Windows (it's a readline bug).
3125 Just press enter and type -- (and press enter again) and the block
3124 Just press enter and type -- (and press enter again) and the block
3126 will be what was just pasted.
3125 will be what was just pasted.
3127
3126
3128 IPython statements (magics, shell escapes) are not supported (yet).
3127 IPython statements (magics, shell escapes) are not supported (yet).
3129 """
3128 """
3130 opts,args = self.parse_options(parameter_s,'s:',mode='string')
3129 opts,args = self.parse_options(parameter_s,'s:',mode='string')
3131 par = args.strip()
3130 par = args.strip()
3132 sentinel = opts.get('s','--')
3131 sentinel = opts.get('s','--')
3133
3132
3134 from IPython import iplib
3133 from IPython import iplib
3135 lines = []
3134 lines = []
3136 print "Pasting code; enter '%s' alone on the line to stop." % sentinel
3135 print "Pasting code; enter '%s' alone on the line to stop." % sentinel
3137 while 1:
3136 while 1:
3138 l = iplib.raw_input_original(':')
3137 l = iplib.raw_input_original(':')
3139 if l ==sentinel:
3138 if l ==sentinel:
3140 break
3139 break
3141 lines.append(l.lstrip('>').lstrip('+'))
3140 lines.append(l.lstrip('>').lstrip('+'))
3142 block = "\n".join(lines) + '\n'
3141 block = "\n".join(lines) + '\n'
3143 #print "block:\n",block
3142 #print "block:\n",block
3144 if not par:
3143 if not par:
3145 b = textwrap.dedent(block)
3144 b = textwrap.dedent(block)
3146 exec b in self.user_ns
3145 exec b in self.user_ns
3147 self.user_ns['pasted_block'] = b
3146 self.user_ns['pasted_block'] = b
3148 else:
3147 else:
3149 self.user_ns[par] = block
3148 self.user_ns[par] = block
3150 print "Block assigned to '%s'" % par
3149 print "Block assigned to '%s'" % par
3151
3150
3152 def magic_quickref(self,arg):
3151 def magic_quickref(self,arg):
3153 """ Show a quick reference sheet """
3152 """ Show a quick reference sheet """
3154 import IPython.usage
3153 import IPython.usage
3155 qr = IPython.usage.quick_reference + self.magic_magic('-brief')
3154 qr = IPython.usage.quick_reference + self.magic_magic('-brief')
3156
3155
3157 page(qr)
3156 page(qr)
3158
3157
3159 def magic_upgrade(self,arg):
3158 def magic_upgrade(self,arg):
3160 """ Upgrade your IPython installation
3159 """ Upgrade your IPython installation
3161
3160
3162 This will copy the config files that don't yet exist in your
3161 This will copy the config files that don't yet exist in your
3163 ipython dir from the system config dir. Use this after upgrading
3162 ipython dir from the system config dir. Use this after upgrading
3164 IPython if you don't wish to delete your .ipython dir.
3163 IPython if you don't wish to delete your .ipython dir.
3165
3164
3166 Call with -nolegacy to get rid of ipythonrc* files (recommended for
3165 Call with -nolegacy to get rid of ipythonrc* files (recommended for
3167 new users)
3166 new users)
3168
3167
3169 """
3168 """
3170 ip = self.getapi()
3169 ip = self.getapi()
3171 ipinstallation = path(IPython.__file__).dirname()
3170 ipinstallation = path(IPython.__file__).dirname()
3172 upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'upgrade_dir.py')
3171 upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'upgrade_dir.py')
3173 src_config = ipinstallation / 'UserConfig'
3172 src_config = ipinstallation / 'UserConfig'
3174 userdir = path(ip.options.ipythondir)
3173 userdir = path(ip.options.ipythondir)
3175 cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
3174 cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
3176 print ">",cmd
3175 print ">",cmd
3177 shell(cmd)
3176 shell(cmd)
3178 if arg == '-nolegacy':
3177 if arg == '-nolegacy':
3179 legacy = userdir.files('ipythonrc*')
3178 legacy = userdir.files('ipythonrc*')
3180 print "Nuking legacy files:",legacy
3179 print "Nuking legacy files:",legacy
3181
3180
3182 [p.remove() for p in legacy]
3181 [p.remove() for p in legacy]
3183 suffix = (sys.platform == 'win32' and '.ini' or '')
3182 suffix = (sys.platform == 'win32' and '.ini' or '')
3184 (userdir / ('ipythonrc' + suffix)).write_text('# Empty, see ipy_user_conf.py\n')
3183 (userdir / ('ipythonrc' + suffix)).write_text('# Empty, see ipy_user_conf.py\n')
3185
3184
3186
3185
3187 def magic_doctest_mode(self,parameter_s=''):
3186 def magic_doctest_mode(self,parameter_s=''):
3188 """Toggle doctest mode on and off.
3187 """Toggle doctest mode on and off.
3189
3188
3190 This mode allows you to toggle the prompt behavior between normal
3189 This mode allows you to toggle the prompt behavior between normal
3191 IPython prompts and ones that are as similar to the default IPython
3190 IPython prompts and ones that are as similar to the default IPython
3192 interpreter as possible.
3191 interpreter as possible.
3193
3192
3194 It also supports the pasting of code snippets that have leading '>>>'
3193 It also supports the pasting of code snippets that have leading '>>>'
3195 and '...' prompts in them. This means that you can paste doctests from
3194 and '...' prompts in them. This means that you can paste doctests from
3196 files or docstrings (even if they have leading whitespace), and the
3195 files or docstrings (even if they have leading whitespace), and the
3197 code will execute correctly. You can then use '%history -tn' to see
3196 code will execute correctly. You can then use '%history -tn' to see
3198 the translated history without line numbers; this will give you the
3197 the translated history without line numbers; this will give you the
3199 input after removal of all the leading prompts and whitespace, which
3198 input after removal of all the leading prompts and whitespace, which
3200 can be pasted back into an editor.
3199 can be pasted back into an editor.
3201
3200
3202 With these features, you can switch into this mode easily whenever you
3201 With these features, you can switch into this mode easily whenever you
3203 need to do testing and changes to doctests, without having to leave
3202 need to do testing and changes to doctests, without having to leave
3204 your existing IPython session.
3203 your existing IPython session.
3205 """
3204 """
3206
3205
3207 # XXX - Fix this to have cleaner activate/deactivate calls.
3206 # XXX - Fix this to have cleaner activate/deactivate calls.
3208 from IPython.Extensions import InterpreterPasteInput as ipaste
3207 from IPython.Extensions import InterpreterPasteInput as ipaste
3209 from IPython.ipstruct import Struct
3208 from IPython.ipstruct import Struct
3210
3209
3211 # Shorthands
3210 # Shorthands
3212 shell = self.shell
3211 shell = self.shell
3213 oc = shell.outputcache
3212 oc = shell.outputcache
3214 rc = shell.rc
3213 rc = shell.rc
3215 meta = shell.meta
3214 meta = shell.meta
3216 # dstore is a data store kept in the instance metadata bag to track any
3215 # dstore is a data store kept in the instance metadata bag to track any
3217 # changes we make, so we can undo them later.
3216 # changes we make, so we can undo them later.
3218 dstore = meta.setdefault('doctest_mode',Struct())
3217 dstore = meta.setdefault('doctest_mode',Struct())
3219 save_dstore = dstore.setdefault
3218 save_dstore = dstore.setdefault
3220
3219
3221 # save a few values we'll need to recover later
3220 # save a few values we'll need to recover later
3222 mode = save_dstore('mode',False)
3221 mode = save_dstore('mode',False)
3223 save_dstore('rc_pprint',rc.pprint)
3222 save_dstore('rc_pprint',rc.pprint)
3224 save_dstore('xmode',shell.InteractiveTB.mode)
3223 save_dstore('xmode',shell.InteractiveTB.mode)
3225 save_dstore('rc_separate_in',rc.separate_in)
3224 save_dstore('rc_separate_in',rc.separate_in)
3226 save_dstore('rc_separate_out',rc.separate_out)
3225 save_dstore('rc_separate_out',rc.separate_out)
3227 save_dstore('rc_separate_out2',rc.separate_out2)
3226 save_dstore('rc_separate_out2',rc.separate_out2)
3228 save_dstore('rc_prompts_pad_left',rc.prompts_pad_left)
3227 save_dstore('rc_prompts_pad_left',rc.prompts_pad_left)
3229
3228
3230 if mode == False:
3229 if mode == False:
3231 # turn on
3230 # turn on
3232 ipaste.activate_prefilter()
3231 ipaste.activate_prefilter()
3233
3232
3234 oc.prompt1.p_template = '>>> '
3233 oc.prompt1.p_template = '>>> '
3235 oc.prompt2.p_template = '... '
3234 oc.prompt2.p_template = '... '
3236 oc.prompt_out.p_template = ''
3235 oc.prompt_out.p_template = ''
3237
3236
3238 oc.prompt1.sep = '\n'
3237 oc.prompt1.sep = '\n'
3239 oc.output_sep = ''
3238 oc.output_sep = ''
3240 oc.output_sep2 = ''
3239 oc.output_sep2 = ''
3241
3240
3242 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3241 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3243 oc.prompt_out.pad_left = False
3242 oc.prompt_out.pad_left = False
3244
3243
3245 rc.pprint = False
3244 rc.pprint = False
3246
3245
3247 shell.magic_xmode('Plain')
3246 shell.magic_xmode('Plain')
3248
3247
3249 else:
3248 else:
3250 # turn off
3249 # turn off
3251 ipaste.deactivate_prefilter()
3250 ipaste.deactivate_prefilter()
3252
3251
3253 oc.prompt1.p_template = rc.prompt_in1
3252 oc.prompt1.p_template = rc.prompt_in1
3254 oc.prompt2.p_template = rc.prompt_in2
3253 oc.prompt2.p_template = rc.prompt_in2
3255 oc.prompt_out.p_template = rc.prompt_out
3254 oc.prompt_out.p_template = rc.prompt_out
3256
3255
3257 oc.prompt1.sep = dstore.rc_separate_in
3256 oc.prompt1.sep = dstore.rc_separate_in
3258 oc.output_sep = dstore.rc_separate_out
3257 oc.output_sep = dstore.rc_separate_out
3259 oc.output_sep2 = dstore.rc_separate_out2
3258 oc.output_sep2 = dstore.rc_separate_out2
3260
3259
3261 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3260 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3262 oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
3261 oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
3263
3262
3264 rc.pprint = dstore.rc_pprint
3263 rc.pprint = dstore.rc_pprint
3265
3264
3266 shell.magic_xmode(dstore.xmode)
3265 shell.magic_xmode(dstore.xmode)
3267
3266
3268 # Store new mode and inform
3267 # Store new mode and inform
3269 dstore.mode = bool(1-int(mode))
3268 dstore.mode = bool(1-int(mode))
3270 print 'Doctest mode is:',
3269 print 'Doctest mode is:',
3271 print ['OFF','ON'][dstore.mode]
3270 print ['OFF','ON'][dstore.mode]
3272
3271
3273 # end Magic
3272 # end Magic
@@ -1,609 +1,616
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 Classes for handling input/output prompts.
3 Classes for handling input/output prompts.
4
4
5 $Id: Prompts.py 2855 2007-11-06 06:53:49Z vivainio $"""
5 $Id: Prompts.py 2899 2007-12-28 08:32:59Z fperez $"""
6
6
7 #*****************************************************************************
7 #*****************************************************************************
8 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
8 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
9 #
9 #
10 # Distributed under the terms of the BSD License. The full license is in
10 # Distributed under the terms of the BSD License. The full license is in
11 # the file COPYING, distributed as part of this software.
11 # the file COPYING, distributed as part of this software.
12 #*****************************************************************************
12 #*****************************************************************************
13
13
14 from IPython import Release
14 from IPython import Release
15 __author__ = '%s <%s>' % Release.authors['Fernando']
15 __author__ = '%s <%s>' % Release.authors['Fernando']
16 __license__ = Release.license
16 __license__ = Release.license
17 __version__ = Release.version
17 __version__ = Release.version
18
18
19 #****************************************************************************
19 #****************************************************************************
20 # Required modules
20 # Required modules
21 import __builtin__
21 import __builtin__
22 import os
22 import os
23 import socket
23 import socket
24 import sys
24 import sys
25 import time
25 import time
26
26
27 # IPython's own
27 # IPython's own
28 from IPython import ColorANSI
28 from IPython import ColorANSI
29 from IPython.Itpl import ItplNS
29 from IPython.Itpl import ItplNS
30 from IPython.ipstruct import Struct
30 from IPython.ipstruct import Struct
31 from IPython.macro import Macro
31 from IPython.macro import Macro
32 from IPython.genutils import *
32 from IPython.genutils import *
33 from IPython.ipapi import TryNext
33 from IPython.ipapi import TryNext
34
34
35 #****************************************************************************
35 #****************************************************************************
36 #Color schemes for Prompts.
36 #Color schemes for Prompts.
37
37
38 PromptColors = ColorANSI.ColorSchemeTable()
38 PromptColors = ColorANSI.ColorSchemeTable()
39 InputColors = ColorANSI.InputTermColors # just a shorthand
39 InputColors = ColorANSI.InputTermColors # just a shorthand
40 Colors = ColorANSI.TermColors # just a shorthand
40 Colors = ColorANSI.TermColors # just a shorthand
41
41
42 PromptColors.add_scheme(ColorANSI.ColorScheme(
42 PromptColors.add_scheme(ColorANSI.ColorScheme(
43 'NoColor',
43 'NoColor',
44 in_prompt = InputColors.NoColor, # Input prompt
44 in_prompt = InputColors.NoColor, # Input prompt
45 in_number = InputColors.NoColor, # Input prompt number
45 in_number = InputColors.NoColor, # Input prompt number
46 in_prompt2 = InputColors.NoColor, # Continuation prompt
46 in_prompt2 = InputColors.NoColor, # Continuation prompt
47 in_normal = InputColors.NoColor, # color off (usu. Colors.Normal)
47 in_normal = InputColors.NoColor, # color off (usu. Colors.Normal)
48
48
49 out_prompt = Colors.NoColor, # Output prompt
49 out_prompt = Colors.NoColor, # Output prompt
50 out_number = Colors.NoColor, # Output prompt number
50 out_number = Colors.NoColor, # Output prompt number
51
51
52 normal = Colors.NoColor # color off (usu. Colors.Normal)
52 normal = Colors.NoColor # color off (usu. Colors.Normal)
53 ))
53 ))
54
54
55 # make some schemes as instances so we can copy them for modification easily:
55 # make some schemes as instances so we can copy them for modification easily:
56 __PColLinux = ColorANSI.ColorScheme(
56 __PColLinux = ColorANSI.ColorScheme(
57 'Linux',
57 'Linux',
58 in_prompt = InputColors.Green,
58 in_prompt = InputColors.Green,
59 in_number = InputColors.LightGreen,
59 in_number = InputColors.LightGreen,
60 in_prompt2 = InputColors.Green,
60 in_prompt2 = InputColors.Green,
61 in_normal = InputColors.Normal, # color off (usu. Colors.Normal)
61 in_normal = InputColors.Normal, # color off (usu. Colors.Normal)
62
62
63 out_prompt = Colors.Red,
63 out_prompt = Colors.Red,
64 out_number = Colors.LightRed,
64 out_number = Colors.LightRed,
65
65
66 normal = Colors.Normal
66 normal = Colors.Normal
67 )
67 )
68 # Don't forget to enter it into the table!
68 # Don't forget to enter it into the table!
69 PromptColors.add_scheme(__PColLinux)
69 PromptColors.add_scheme(__PColLinux)
70
70
71 # Slightly modified Linux for light backgrounds
71 # Slightly modified Linux for light backgrounds
72 __PColLightBG = __PColLinux.copy('LightBG')
72 __PColLightBG = __PColLinux.copy('LightBG')
73
73
74 __PColLightBG.colors.update(
74 __PColLightBG.colors.update(
75 in_prompt = InputColors.Blue,
75 in_prompt = InputColors.Blue,
76 in_number = InputColors.LightBlue,
76 in_number = InputColors.LightBlue,
77 in_prompt2 = InputColors.Blue
77 in_prompt2 = InputColors.Blue
78 )
78 )
79 PromptColors.add_scheme(__PColLightBG)
79 PromptColors.add_scheme(__PColLightBG)
80
80
81 del Colors,InputColors
81 del Colors,InputColors
82
82
83 #-----------------------------------------------------------------------------
83 #-----------------------------------------------------------------------------
84 def multiple_replace(dict, text):
84 def multiple_replace(dict, text):
85 """ Replace in 'text' all occurences of any key in the given
85 """ Replace in 'text' all occurences of any key in the given
86 dictionary by its corresponding value. Returns the new string."""
86 dictionary by its corresponding value. Returns the new string."""
87
87
88 # Function by Xavier Defrang, originally found at:
88 # Function by Xavier Defrang, originally found at:
89 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
89 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
90
90
91 # Create a regular expression from the dictionary keys
91 # Create a regular expression from the dictionary keys
92 regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
92 regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
93 # For each match, look-up corresponding value in dictionary
93 # For each match, look-up corresponding value in dictionary
94 return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
94 return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
95
95
96 #-----------------------------------------------------------------------------
96 #-----------------------------------------------------------------------------
97 # Special characters that can be used in prompt templates, mainly bash-like
97 # Special characters that can be used in prompt templates, mainly bash-like
98
98
99 # If $HOME isn't defined (Windows), make it an absurd string so that it can
99 # If $HOME isn't defined (Windows), make it an absurd string so that it can
100 # never be expanded out into '~'. Basically anything which can never be a
100 # never be expanded out into '~'. Basically anything which can never be a
101 # reasonable directory name will do, we just want the $HOME -> '~' operation
101 # reasonable directory name will do, we just want the $HOME -> '~' operation
102 # to become a no-op. We pre-compute $HOME here so it's not done on every
102 # to become a no-op. We pre-compute $HOME here so it's not done on every
103 # prompt call.
103 # prompt call.
104
104
105 # FIXME:
105 # FIXME:
106
106
107 # - This should be turned into a class which does proper namespace management,
107 # - This should be turned into a class which does proper namespace management,
108 # since the prompt specials need to be evaluated in a certain namespace.
108 # since the prompt specials need to be evaluated in a certain namespace.
109 # Currently it's just globals, which need to be managed manually by code
109 # Currently it's just globals, which need to be managed manually by code
110 # below.
110 # below.
111
111
112 # - I also need to split up the color schemes from the prompt specials
112 # - I also need to split up the color schemes from the prompt specials
113 # somehow. I don't have a clean design for that quite yet.
113 # somehow. I don't have a clean design for that quite yet.
114
114
115 HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~")
115 HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~")
116
116
117 # We precompute a few more strings here for the prompt_specials, which are
117 # We precompute a few more strings here for the prompt_specials, which are
118 # fixed once ipython starts. This reduces the runtime overhead of computing
118 # fixed once ipython starts. This reduces the runtime overhead of computing
119 # prompt strings.
119 # prompt strings.
120 USER = os.environ.get("USER")
120 USER = os.environ.get("USER")
121 HOSTNAME = socket.gethostname()
121 HOSTNAME = socket.gethostname()
122 HOSTNAME_SHORT = HOSTNAME.split(".")[0]
122 HOSTNAME_SHORT = HOSTNAME.split(".")[0]
123 ROOT_SYMBOL = "$#"[os.name=='nt' or os.getuid()==0]
123 ROOT_SYMBOL = "$#"[os.name=='nt' or os.getuid()==0]
124
124
125 prompt_specials_color = {
125 prompt_specials_color = {
126 # Prompt/history count
126 # Prompt/history count
127 '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
127 '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
128 r'\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
128 r'\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
129 # Just the prompt counter number, WITHOUT any coloring wrappers, so users
129 # Just the prompt counter number, WITHOUT any coloring wrappers, so users
130 # can get numbers displayed in whatever color they want.
130 # can get numbers displayed in whatever color they want.
131 r'\N': '${self.cache.prompt_count}',
131 r'\N': '${self.cache.prompt_count}',
132 # Prompt/history count, with the actual digits replaced by dots. Used
132 # Prompt/history count, with the actual digits replaced by dots. Used
133 # mainly in continuation prompts (prompt_in2)
133 # mainly in continuation prompts (prompt_in2)
134 r'\D': '${"."*len(str(self.cache.prompt_count))}',
134 r'\D': '${"."*len(str(self.cache.prompt_count))}',
135 # Current working directory
135 # Current working directory
136 r'\w': '${os.getcwd()}',
136 r'\w': '${os.getcwd()}',
137 # Current time
137 # Current time
138 r'\t' : '${time.strftime("%H:%M:%S")}',
138 r'\t' : '${time.strftime("%H:%M:%S")}',
139 # Basename of current working directory.
139 # Basename of current working directory.
140 # (use os.sep to make this portable across OSes)
140 # (use os.sep to make this portable across OSes)
141 r'\W' : '${os.getcwd().split("%s")[-1]}' % os.sep,
141 r'\W' : '${os.getcwd().split("%s")[-1]}' % os.sep,
142 # These X<N> are an extension to the normal bash prompts. They return
142 # These X<N> are an extension to the normal bash prompts. They return
143 # N terms of the path, after replacing $HOME with '~'
143 # N terms of the path, after replacing $HOME with '~'
144 r'\X0': '${os.getcwd().replace("%s","~")}' % HOME,
144 r'\X0': '${os.getcwd().replace("%s","~")}' % HOME,
145 r'\X1': '${self.cwd_filt(1)}',
145 r'\X1': '${self.cwd_filt(1)}',
146 r'\X2': '${self.cwd_filt(2)}',
146 r'\X2': '${self.cwd_filt(2)}',
147 r'\X3': '${self.cwd_filt(3)}',
147 r'\X3': '${self.cwd_filt(3)}',
148 r'\X4': '${self.cwd_filt(4)}',
148 r'\X4': '${self.cwd_filt(4)}',
149 r'\X5': '${self.cwd_filt(5)}',
149 r'\X5': '${self.cwd_filt(5)}',
150 # Y<N> are similar to X<N>, but they show '~' if it's the directory
150 # Y<N> are similar to X<N>, but they show '~' if it's the directory
151 # N+1 in the list. Somewhat like %cN in tcsh.
151 # N+1 in the list. Somewhat like %cN in tcsh.
152 r'\Y0': '${self.cwd_filt2(0)}',
152 r'\Y0': '${self.cwd_filt2(0)}',
153 r'\Y1': '${self.cwd_filt2(1)}',
153 r'\Y1': '${self.cwd_filt2(1)}',
154 r'\Y2': '${self.cwd_filt2(2)}',
154 r'\Y2': '${self.cwd_filt2(2)}',
155 r'\Y3': '${self.cwd_filt2(3)}',
155 r'\Y3': '${self.cwd_filt2(3)}',
156 r'\Y4': '${self.cwd_filt2(4)}',
156 r'\Y4': '${self.cwd_filt2(4)}',
157 r'\Y5': '${self.cwd_filt2(5)}',
157 r'\Y5': '${self.cwd_filt2(5)}',
158 # Hostname up to first .
158 # Hostname up to first .
159 r'\h': HOSTNAME_SHORT,
159 r'\h': HOSTNAME_SHORT,
160 # Full hostname
160 # Full hostname
161 r'\H': HOSTNAME,
161 r'\H': HOSTNAME,
162 # Username of current user
162 # Username of current user
163 r'\u': USER,
163 r'\u': USER,
164 # Escaped '\'
164 # Escaped '\'
165 '\\\\': '\\',
165 '\\\\': '\\',
166 # Newline
166 # Newline
167 r'\n': '\n',
167 r'\n': '\n',
168 # Carriage return
168 # Carriage return
169 r'\r': '\r',
169 r'\r': '\r',
170 # Release version
170 # Release version
171 r'\v': __version__,
171 r'\v': __version__,
172 # Root symbol ($ or #)
172 # Root symbol ($ or #)
173 r'\$': ROOT_SYMBOL,
173 r'\$': ROOT_SYMBOL,
174 }
174 }
175
175
176 # A copy of the prompt_specials dictionary but with all color escapes removed,
176 # A copy of the prompt_specials dictionary but with all color escapes removed,
177 # so we can correctly compute the prompt length for the auto_rewrite method.
177 # so we can correctly compute the prompt length for the auto_rewrite method.
178 prompt_specials_nocolor = prompt_specials_color.copy()
178 prompt_specials_nocolor = prompt_specials_color.copy()
179 prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}'
179 prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}'
180 prompt_specials_nocolor[r'\#'] = '${self.cache.prompt_count}'
180 prompt_specials_nocolor[r'\#'] = '${self.cache.prompt_count}'
181
181
182 # Add in all the InputTermColors color escapes as valid prompt characters.
182 # Add in all the InputTermColors color escapes as valid prompt characters.
183 # They all get added as \\C_COLORNAME, so that we don't have any conflicts
183 # They all get added as \\C_COLORNAME, so that we don't have any conflicts
184 # with a color name which may begin with a letter used by any other of the
184 # with a color name which may begin with a letter used by any other of the
185 # allowed specials. This of course means that \\C will never be allowed for
185 # allowed specials. This of course means that \\C will never be allowed for
186 # anything else.
186 # anything else.
187 input_colors = ColorANSI.InputTermColors
187 input_colors = ColorANSI.InputTermColors
188 for _color in dir(input_colors):
188 for _color in dir(input_colors):
189 if _color[0] != '_':
189 if _color[0] != '_':
190 c_name = r'\C_'+_color
190 c_name = r'\C_'+_color
191 prompt_specials_color[c_name] = getattr(input_colors,_color)
191 prompt_specials_color[c_name] = getattr(input_colors,_color)
192 prompt_specials_nocolor[c_name] = ''
192 prompt_specials_nocolor[c_name] = ''
193
193
194 # we default to no color for safety. Note that prompt_specials is a global
194 # we default to no color for safety. Note that prompt_specials is a global
195 # variable used by all prompt objects.
195 # variable used by all prompt objects.
196 prompt_specials = prompt_specials_nocolor
196 prompt_specials = prompt_specials_nocolor
197
197
198 #-----------------------------------------------------------------------------
198 #-----------------------------------------------------------------------------
199 def str_safe(arg):
199 def str_safe(arg):
200 """Convert to a string, without ever raising an exception.
200 """Convert to a string, without ever raising an exception.
201
201
202 If str(arg) fails, <ERROR: ... > is returned, where ... is the exception
202 If str(arg) fails, <ERROR: ... > is returned, where ... is the exception
203 error message."""
203 error message."""
204
204
205 try:
205 try:
206 out = str(arg)
206 out = str(arg)
207 except UnicodeError:
207 except UnicodeError:
208 try:
208 try:
209 out = arg.encode('utf_8','replace')
209 out = arg.encode('utf_8','replace')
210 except Exception,msg:
210 except Exception,msg:
211 # let's keep this little duplication here, so that the most common
211 # let's keep this little duplication here, so that the most common
212 # case doesn't suffer from a double try wrapping.
212 # case doesn't suffer from a double try wrapping.
213 out = '<ERROR: %s>' % msg
213 out = '<ERROR: %s>' % msg
214 except Exception,msg:
214 except Exception,msg:
215 out = '<ERROR: %s>' % msg
215 out = '<ERROR: %s>' % msg
216 return out
216 return out
217
217
218 class BasePrompt(object):
218 class BasePrompt(object):
219 """Interactive prompt similar to Mathematica's."""
219 """Interactive prompt similar to Mathematica's."""
220
220
221 def _get_p_template(self):
221 def _get_p_template(self):
222 return self._p_template
222 return self._p_template
223
223
224 def _set_p_template(self,val):
224 def _set_p_template(self,val):
225 self._p_template = val
225 self._p_template = val
226 self.set_p_str()
226 self.set_p_str()
227
227
228 p_template = property(_get_p_template,_set_p_template,
228 p_template = property(_get_p_template,_set_p_template,
229 doc='Template for prompt string creation')
229 doc='Template for prompt string creation')
230
230
231 def __init__(self,cache,sep,prompt,pad_left=False):
231 def __init__(self,cache,sep,prompt,pad_left=False):
232
232
233 # Hack: we access information about the primary prompt through the
233 # Hack: we access information about the primary prompt through the
234 # cache argument. We need this, because we want the secondary prompt
234 # cache argument. We need this, because we want the secondary prompt
235 # to be aligned with the primary one. Color table info is also shared
235 # to be aligned with the primary one. Color table info is also shared
236 # by all prompt classes through the cache. Nice OO spaghetti code!
236 # by all prompt classes through the cache. Nice OO spaghetti code!
237 self.cache = cache
237 self.cache = cache
238 self.sep = sep
238 self.sep = sep
239
239
240 # regexp to count the number of spaces at the end of a prompt
240 # regexp to count the number of spaces at the end of a prompt
241 # expression, useful for prompt auto-rewriting
241 # expression, useful for prompt auto-rewriting
242 self.rspace = re.compile(r'(\s*)$')
242 self.rspace = re.compile(r'(\s*)$')
243 # Flag to left-pad prompt strings to match the length of the primary
243 # Flag to left-pad prompt strings to match the length of the primary
244 # prompt
244 # prompt
245 self.pad_left = pad_left
245 self.pad_left = pad_left
246
246
247 # Set template to create each actual prompt (where numbers change).
247 # Set template to create each actual prompt (where numbers change).
248 # Use a property
248 # Use a property
249 self.p_template = prompt
249 self.p_template = prompt
250 self.set_p_str()
250 self.set_p_str()
251
251
252 def set_p_str(self):
252 def set_p_str(self):
253 """ Set the interpolating prompt strings.
253 """ Set the interpolating prompt strings.
254
254
255 This must be called every time the color settings change, because the
255 This must be called every time the color settings change, because the
256 prompt_specials global may have changed."""
256 prompt_specials global may have changed."""
257
257
258 import os,time # needed in locals for prompt string handling
258 import os,time # needed in locals for prompt string handling
259 loc = locals()
259 loc = locals()
260 self.p_str = ItplNS('%s%s%s' %
260 self.p_str = ItplNS('%s%s%s' %
261 ('${self.sep}${self.col_p}',
261 ('${self.sep}${self.col_p}',
262 multiple_replace(prompt_specials, self.p_template),
262 multiple_replace(prompt_specials, self.p_template),
263 '${self.col_norm}'),self.cache.user_ns,loc)
263 '${self.col_norm}'),self.cache.user_ns,loc)
264
264
265 self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
265 self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
266 self.p_template),
266 self.p_template),
267 self.cache.user_ns,loc)
267 self.cache.user_ns,loc)
268
268
269 def write(self,msg): # dbg
269 def write(self,msg): # dbg
270 sys.stdout.write(msg)
270 sys.stdout.write(msg)
271 return ''
271 return ''
272
272
273 def __str__(self):
273 def __str__(self):
274 """Return a string form of the prompt.
274 """Return a string form of the prompt.
275
275
276 This for is useful for continuation and output prompts, since it is
276 This for is useful for continuation and output prompts, since it is
277 left-padded to match lengths with the primary one (if the
277 left-padded to match lengths with the primary one (if the
278 self.pad_left attribute is set)."""
278 self.pad_left attribute is set)."""
279
279
280 out_str = str_safe(self.p_str)
280 out_str = str_safe(self.p_str)
281 if self.pad_left:
281 if self.pad_left:
282 # We must find the amount of padding required to match lengths,
282 # We must find the amount of padding required to match lengths,
283 # taking the color escapes (which are invisible on-screen) into
283 # taking the color escapes (which are invisible on-screen) into
284 # account.
284 # account.
285 esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor))
285 esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor))
286 format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad)
286 format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad)
287 return format % out_str
287 return format % out_str
288 else:
288 else:
289 return out_str
289 return out_str
290
290
291 # these path filters are put in as methods so that we can control the
291 # these path filters are put in as methods so that we can control the
292 # namespace where the prompt strings get evaluated
292 # namespace where the prompt strings get evaluated
293 def cwd_filt(self,depth):
293 def cwd_filt(self,depth):
294 """Return the last depth elements of the current working directory.
294 """Return the last depth elements of the current working directory.
295
295
296 $HOME is always replaced with '~'.
296 $HOME is always replaced with '~'.
297 If depth==0, the full path is returned."""
297 If depth==0, the full path is returned."""
298
298
299 cwd = os.getcwd().replace(HOME,"~")
299 cwd = os.getcwd().replace(HOME,"~")
300 out = os.sep.join(cwd.split(os.sep)[-depth:])
300 out = os.sep.join(cwd.split(os.sep)[-depth:])
301 if out:
301 if out:
302 return out
302 return out
303 else:
303 else:
304 return os.sep
304 return os.sep
305
305
306 def cwd_filt2(self,depth):
306 def cwd_filt2(self,depth):
307 """Return the last depth elements of the current working directory.
307 """Return the last depth elements of the current working directory.
308
308
309 $HOME is always replaced with '~'.
309 $HOME is always replaced with '~'.
310 If depth==0, the full path is returned."""
310 If depth==0, the full path is returned."""
311
311
312 full_cwd = os.getcwd()
312 full_cwd = os.getcwd()
313 cwd = full_cwd.replace(HOME,"~").split(os.sep)
313 cwd = full_cwd.replace(HOME,"~").split(os.sep)
314 if '~' in cwd and len(cwd) == depth+1:
314 if '~' in cwd and len(cwd) == depth+1:
315 depth += 1
315 depth += 1
316 drivepart = ''
316 drivepart = ''
317 if sys.platform == 'win32' and len(cwd) > depth:
317 if sys.platform == 'win32' and len(cwd) > depth:
318 drivepart = os.path.splitdrive(full_cwd)[0]
318 drivepart = os.path.splitdrive(full_cwd)[0]
319 out = drivepart + '/'.join(cwd[-depth:])
319 out = drivepart + '/'.join(cwd[-depth:])
320
320
321 if out:
321 if out:
322 return out
322 return out
323 else:
323 else:
324 return os.sep
324 return os.sep
325
325
326 def __nonzero__(self):
327 """Implement boolean behavior.
328
329 Checks whether the p_str attribute is non-empty"""
330
331 return bool(self.p_template)
332
326 class Prompt1(BasePrompt):
333 class Prompt1(BasePrompt):
327 """Input interactive prompt similar to Mathematica's."""
334 """Input interactive prompt similar to Mathematica's."""
328
335
329 def __init__(self,cache,sep='\n',prompt='In [\\#]: ',pad_left=True):
336 def __init__(self,cache,sep='\n',prompt='In [\\#]: ',pad_left=True):
330 BasePrompt.__init__(self,cache,sep,prompt,pad_left)
337 BasePrompt.__init__(self,cache,sep,prompt,pad_left)
331
338
332 def set_colors(self):
339 def set_colors(self):
333 self.set_p_str()
340 self.set_p_str()
334 Colors = self.cache.color_table.active_colors # shorthand
341 Colors = self.cache.color_table.active_colors # shorthand
335 self.col_p = Colors.in_prompt
342 self.col_p = Colors.in_prompt
336 self.col_num = Colors.in_number
343 self.col_num = Colors.in_number
337 self.col_norm = Colors.in_normal
344 self.col_norm = Colors.in_normal
338 # We need a non-input version of these escapes for the '--->'
345 # We need a non-input version of these escapes for the '--->'
339 # auto-call prompts used in the auto_rewrite() method.
346 # auto-call prompts used in the auto_rewrite() method.
340 self.col_p_ni = self.col_p.replace('\001','').replace('\002','')
347 self.col_p_ni = self.col_p.replace('\001','').replace('\002','')
341 self.col_norm_ni = Colors.normal
348 self.col_norm_ni = Colors.normal
342
349
343 def __str__(self):
350 def __str__(self):
344 self.cache.prompt_count += 1
351 self.cache.prompt_count += 1
345 self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
352 self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
346 return str_safe(self.p_str)
353 return str_safe(self.p_str)
347
354
348 def auto_rewrite(self):
355 def auto_rewrite(self):
349 """Print a string of the form '--->' which lines up with the previous
356 """Print a string of the form '--->' which lines up with the previous
350 input string. Useful for systems which re-write the user input when
357 input string. Useful for systems which re-write the user input when
351 handling automatically special syntaxes."""
358 handling automatically special syntaxes."""
352
359
353 curr = str(self.cache.last_prompt)
360 curr = str(self.cache.last_prompt)
354 nrspaces = len(self.rspace.search(curr).group())
361 nrspaces = len(self.rspace.search(curr).group())
355 return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1),
362 return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1),
356 ' '*nrspaces,self.col_norm_ni)
363 ' '*nrspaces,self.col_norm_ni)
357
364
358 class PromptOut(BasePrompt):
365 class PromptOut(BasePrompt):
359 """Output interactive prompt similar to Mathematica's."""
366 """Output interactive prompt similar to Mathematica's."""
360
367
361 def __init__(self,cache,sep='',prompt='Out[\\#]: ',pad_left=True):
368 def __init__(self,cache,sep='',prompt='Out[\\#]: ',pad_left=True):
362 BasePrompt.__init__(self,cache,sep,prompt,pad_left)
369 BasePrompt.__init__(self,cache,sep,prompt,pad_left)
363 if not self.p_template:
370 if not self.p_template:
364 self.__str__ = lambda: ''
371 self.__str__ = lambda: ''
365
372
366 def set_colors(self):
373 def set_colors(self):
367 self.set_p_str()
374 self.set_p_str()
368 Colors = self.cache.color_table.active_colors # shorthand
375 Colors = self.cache.color_table.active_colors # shorthand
369 self.col_p = Colors.out_prompt
376 self.col_p = Colors.out_prompt
370 self.col_num = Colors.out_number
377 self.col_num = Colors.out_number
371 self.col_norm = Colors.normal
378 self.col_norm = Colors.normal
372
379
373 class Prompt2(BasePrompt):
380 class Prompt2(BasePrompt):
374 """Interactive continuation prompt."""
381 """Interactive continuation prompt."""
375
382
376 def __init__(self,cache,prompt=' .\\D.: ',pad_left=True):
383 def __init__(self,cache,prompt=' .\\D.: ',pad_left=True):
377 self.cache = cache
384 self.cache = cache
378 self.p_template = prompt
385 self.p_template = prompt
379 self.pad_left = pad_left
386 self.pad_left = pad_left
380 self.set_p_str()
387 self.set_p_str()
381
388
382 def set_p_str(self):
389 def set_p_str(self):
383 import os,time # needed in locals for prompt string handling
390 import os,time # needed in locals for prompt string handling
384 loc = locals()
391 loc = locals()
385 self.p_str = ItplNS('%s%s%s' %
392 self.p_str = ItplNS('%s%s%s' %
386 ('${self.col_p2}',
393 ('${self.col_p2}',
387 multiple_replace(prompt_specials, self.p_template),
394 multiple_replace(prompt_specials, self.p_template),
388 '$self.col_norm'),
395 '$self.col_norm'),
389 self.cache.user_ns,loc)
396 self.cache.user_ns,loc)
390 self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
397 self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
391 self.p_template),
398 self.p_template),
392 self.cache.user_ns,loc)
399 self.cache.user_ns,loc)
393
400
394 def set_colors(self):
401 def set_colors(self):
395 self.set_p_str()
402 self.set_p_str()
396 Colors = self.cache.color_table.active_colors
403 Colors = self.cache.color_table.active_colors
397 self.col_p2 = Colors.in_prompt2
404 self.col_p2 = Colors.in_prompt2
398 self.col_norm = Colors.in_normal
405 self.col_norm = Colors.in_normal
399 # FIXME (2004-06-16) HACK: prevent crashes for users who haven't
406 # FIXME (2004-06-16) HACK: prevent crashes for users who haven't
400 # updated their prompt_in2 definitions. Remove eventually.
407 # updated their prompt_in2 definitions. Remove eventually.
401 self.col_p = Colors.out_prompt
408 self.col_p = Colors.out_prompt
402 self.col_num = Colors.out_number
409 self.col_num = Colors.out_number
403
410
404
411
405 #-----------------------------------------------------------------------------
412 #-----------------------------------------------------------------------------
406 class CachedOutput:
413 class CachedOutput:
407 """Class for printing output from calculations while keeping a cache of
414 """Class for printing output from calculations while keeping a cache of
408 reults. It dynamically creates global variables prefixed with _ which
415 reults. It dynamically creates global variables prefixed with _ which
409 contain these results.
416 contain these results.
410
417
411 Meant to be used as a sys.displayhook replacement, providing numbered
418 Meant to be used as a sys.displayhook replacement, providing numbered
412 prompts and cache services.
419 prompts and cache services.
413
420
414 Initialize with initial and final values for cache counter (this defines
421 Initialize with initial and final values for cache counter (this defines
415 the maximum size of the cache."""
422 the maximum size of the cache."""
416
423
417 def __init__(self,shell,cache_size,Pprint,
424 def __init__(self,shell,cache_size,Pprint,
418 colors='NoColor',input_sep='\n',
425 colors='NoColor',input_sep='\n',
419 output_sep='\n',output_sep2='',
426 output_sep='\n',output_sep2='',
420 ps1 = None, ps2 = None,ps_out = None,pad_left=True):
427 ps1 = None, ps2 = None,ps_out = None,pad_left=True):
421
428
422 cache_size_min = 3
429 cache_size_min = 3
423 if cache_size <= 0:
430 if cache_size <= 0:
424 self.do_full_cache = 0
431 self.do_full_cache = 0
425 cache_size = 0
432 cache_size = 0
426 elif cache_size < cache_size_min:
433 elif cache_size < cache_size_min:
427 self.do_full_cache = 0
434 self.do_full_cache = 0
428 cache_size = 0
435 cache_size = 0
429 warn('caching was disabled (min value for cache size is %s).' %
436 warn('caching was disabled (min value for cache size is %s).' %
430 cache_size_min,level=3)
437 cache_size_min,level=3)
431 else:
438 else:
432 self.do_full_cache = 1
439 self.do_full_cache = 1
433
440
434 self.cache_size = cache_size
441 self.cache_size = cache_size
435 self.input_sep = input_sep
442 self.input_sep = input_sep
436
443
437 # we need a reference to the user-level namespace
444 # we need a reference to the user-level namespace
438 self.shell = shell
445 self.shell = shell
439 self.user_ns = shell.user_ns
446 self.user_ns = shell.user_ns
440 # and to the user's input
447 # and to the user's input
441 self.input_hist = shell.input_hist
448 self.input_hist = shell.input_hist
442 # and to the user's logger, for logging output
449 # and to the user's logger, for logging output
443 self.logger = shell.logger
450 self.logger = shell.logger
444
451
445 # Set input prompt strings and colors
452 # Set input prompt strings and colors
446 if cache_size == 0:
453 if cache_size == 0:
447 if ps1.find('%n') > -1 or ps1.find(r'\#') > -1 \
454 if ps1.find('%n') > -1 or ps1.find(r'\#') > -1 \
448 or ps1.find(r'\N') > -1:
455 or ps1.find(r'\N') > -1:
449 ps1 = '>>> '
456 ps1 = '>>> '
450 if ps2.find('%n') > -1 or ps2.find(r'\#') > -1 \
457 if ps2.find('%n') > -1 or ps2.find(r'\#') > -1 \
451 or ps2.find(r'\N') > -1:
458 or ps2.find(r'\N') > -1:
452 ps2 = '... '
459 ps2 = '... '
453 self.ps1_str = self._set_prompt_str(ps1,'In [\\#]: ','>>> ')
460 self.ps1_str = self._set_prompt_str(ps1,'In [\\#]: ','>>> ')
454 self.ps2_str = self._set_prompt_str(ps2,' .\\D.: ','... ')
461 self.ps2_str = self._set_prompt_str(ps2,' .\\D.: ','... ')
455 self.ps_out_str = self._set_prompt_str(ps_out,'Out[\\#]: ','')
462 self.ps_out_str = self._set_prompt_str(ps_out,'Out[\\#]: ','')
456
463
457 self.color_table = PromptColors
464 self.color_table = PromptColors
458 self.prompt1 = Prompt1(self,sep=input_sep,prompt=self.ps1_str,
465 self.prompt1 = Prompt1(self,sep=input_sep,prompt=self.ps1_str,
459 pad_left=pad_left)
466 pad_left=pad_left)
460 self.prompt2 = Prompt2(self,prompt=self.ps2_str,pad_left=pad_left)
467 self.prompt2 = Prompt2(self,prompt=self.ps2_str,pad_left=pad_left)
461 self.prompt_out = PromptOut(self,sep='',prompt=self.ps_out_str,
468 self.prompt_out = PromptOut(self,sep='',prompt=self.ps_out_str,
462 pad_left=pad_left)
469 pad_left=pad_left)
463 self.set_colors(colors)
470 self.set_colors(colors)
464
471
465 # other more normal stuff
472 # other more normal stuff
466 # b/c each call to the In[] prompt raises it by 1, even the first.
473 # b/c each call to the In[] prompt raises it by 1, even the first.
467 self.prompt_count = 0
474 self.prompt_count = 0
468 # Store the last prompt string each time, we need it for aligning
475 # Store the last prompt string each time, we need it for aligning
469 # continuation and auto-rewrite prompts
476 # continuation and auto-rewrite prompts
470 self.last_prompt = ''
477 self.last_prompt = ''
471 self.Pprint = Pprint
478 self.Pprint = Pprint
472 self.output_sep = output_sep
479 self.output_sep = output_sep
473 self.output_sep2 = output_sep2
480 self.output_sep2 = output_sep2
474 self._,self.__,self.___ = '','',''
481 self._,self.__,self.___ = '','',''
475 self.pprint_types = map(type,[(),[],{}])
482 self.pprint_types = map(type,[(),[],{}])
476
483
477 # these are deliberately global:
484 # these are deliberately global:
478 to_user_ns = {'_':self._,'__':self.__,'___':self.___}
485 to_user_ns = {'_':self._,'__':self.__,'___':self.___}
479 self.user_ns.update(to_user_ns)
486 self.user_ns.update(to_user_ns)
480
487
481 def _set_prompt_str(self,p_str,cache_def,no_cache_def):
488 def _set_prompt_str(self,p_str,cache_def,no_cache_def):
482 if p_str is None:
489 if p_str is None:
483 if self.do_full_cache:
490 if self.do_full_cache:
484 return cache_def
491 return cache_def
485 else:
492 else:
486 return no_cache_def
493 return no_cache_def
487 else:
494 else:
488 return p_str
495 return p_str
489
496
490 def set_colors(self,colors):
497 def set_colors(self,colors):
491 """Set the active color scheme and configure colors for the three
498 """Set the active color scheme and configure colors for the three
492 prompt subsystems."""
499 prompt subsystems."""
493
500
494 # FIXME: the prompt_specials global should be gobbled inside this
501 # FIXME: the prompt_specials global should be gobbled inside this
495 # class instead. Do it when cleaning up the whole 3-prompt system.
502 # class instead. Do it when cleaning up the whole 3-prompt system.
496 global prompt_specials
503 global prompt_specials
497 if colors.lower()=='nocolor':
504 if colors.lower()=='nocolor':
498 prompt_specials = prompt_specials_nocolor
505 prompt_specials = prompt_specials_nocolor
499 else:
506 else:
500 prompt_specials = prompt_specials_color
507 prompt_specials = prompt_specials_color
501
508
502 self.color_table.set_active_scheme(colors)
509 self.color_table.set_active_scheme(colors)
503 self.prompt1.set_colors()
510 self.prompt1.set_colors()
504 self.prompt2.set_colors()
511 self.prompt2.set_colors()
505 self.prompt_out.set_colors()
512 self.prompt_out.set_colors()
506
513
507 def __call__(self,arg=None):
514 def __call__(self,arg=None):
508 """Printing with history cache management.
515 """Printing with history cache management.
509
516
510 This is invoked everytime the interpreter needs to print, and is
517 This is invoked everytime the interpreter needs to print, and is
511 activated by setting the variable sys.displayhook to it."""
518 activated by setting the variable sys.displayhook to it."""
512
519
513 # If something injected a '_' variable in __builtin__, delete
520 # If something injected a '_' variable in __builtin__, delete
514 # ipython's automatic one so we don't clobber that. gettext() in
521 # ipython's automatic one so we don't clobber that. gettext() in
515 # particular uses _, so we need to stay away from it.
522 # particular uses _, so we need to stay away from it.
516 if '_' in __builtin__.__dict__:
523 if '_' in __builtin__.__dict__:
517 try:
524 try:
518 del self.user_ns['_']
525 del self.user_ns['_']
519 except KeyError:
526 except KeyError:
520 pass
527 pass
521 if arg is not None:
528 if arg is not None:
522 cout_write = Term.cout.write # fast lookup
529 cout_write = Term.cout.write # fast lookup
523 # first handle the cache and counters
530 # first handle the cache and counters
524
531
525 # do not print output if input ends in ';'
532 # do not print output if input ends in ';'
526 if self.input_hist[self.prompt_count].endswith(';\n'):
533 if self.input_hist[self.prompt_count].endswith(';\n'):
527 return
534 return
528 # don't use print, puts an extra space
535 # don't use print, puts an extra space
529 cout_write(self.output_sep)
536 cout_write(self.output_sep)
530 outprompt = self.shell.hooks.generate_output_prompt()
537 outprompt = self.shell.hooks.generate_output_prompt()
531 if self.do_full_cache:
538 if self.do_full_cache:
532 cout_write(outprompt)
539 cout_write(outprompt)
533
540
534 # and now call a possibly user-defined print mechanism
541 # and now call a possibly user-defined print mechanism
535 manipulated_val = self.display(arg)
542 manipulated_val = self.display(arg)
536
543
537 # user display hooks can change the variable to be stored in
544 # user display hooks can change the variable to be stored in
538 # output history
545 # output history
539
546
540 if manipulated_val is not None:
547 if manipulated_val is not None:
541 arg = manipulated_val
548 arg = manipulated_val
542
549
543 # avoid recursive reference when displaying _oh/Out
550 # avoid recursive reference when displaying _oh/Out
544 if arg is not self.user_ns['_oh']:
551 if arg is not self.user_ns['_oh']:
545 self.update(arg)
552 self.update(arg)
546
553
547 if self.logger.log_output:
554 if self.logger.log_output:
548 self.logger.log_write(repr(arg),'output')
555 self.logger.log_write(repr(arg),'output')
549 cout_write(self.output_sep2)
556 cout_write(self.output_sep2)
550 Term.cout.flush()
557 Term.cout.flush()
551
558
552 def _display(self,arg):
559 def _display(self,arg):
553 """Default printer method, uses pprint.
560 """Default printer method, uses pprint.
554
561
555 Do ip.set_hook("result_display", my_displayhook) for custom result
562 Do ip.set_hook("result_display", my_displayhook) for custom result
556 display, e.g. when your own objects need special formatting.
563 display, e.g. when your own objects need special formatting.
557 """
564 """
558 try:
565 try:
559 return IPython.generics.result_display(arg)
566 return IPython.generics.result_display(arg)
560 except TryNext:
567 except TryNext:
561 return self.shell.hooks.result_display(arg)
568 return self.shell.hooks.result_display(arg)
562
569
563 # Assign the default display method:
570 # Assign the default display method:
564 display = _display
571 display = _display
565
572
566 def update(self,arg):
573 def update(self,arg):
567 #print '***cache_count', self.cache_count # dbg
574 #print '***cache_count', self.cache_count # dbg
568 if len(self.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
575 if len(self.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
569 warn('Output cache limit (currently '+
576 warn('Output cache limit (currently '+
570 `self.cache_size`+' entries) hit.\n'
577 `self.cache_size`+' entries) hit.\n'
571 'Flushing cache and resetting history counter...\n'
578 'Flushing cache and resetting history counter...\n'
572 'The only history variables available will be _,__,___ and _1\n'
579 'The only history variables available will be _,__,___ and _1\n'
573 'with the current result.')
580 'with the current result.')
574
581
575 self.flush()
582 self.flush()
576 # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
583 # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
577 # we cause buggy behavior for things like gettext).
584 # we cause buggy behavior for things like gettext).
578 if '_' not in __builtin__.__dict__:
585 if '_' not in __builtin__.__dict__:
579 self.___ = self.__
586 self.___ = self.__
580 self.__ = self._
587 self.__ = self._
581 self._ = arg
588 self._ = arg
582 self.user_ns.update({'_':self._,'__':self.__,'___':self.___})
589 self.user_ns.update({'_':self._,'__':self.__,'___':self.___})
583
590
584 # hackish access to top-level namespace to create _1,_2... dynamically
591 # hackish access to top-level namespace to create _1,_2... dynamically
585 to_main = {}
592 to_main = {}
586 if self.do_full_cache:
593 if self.do_full_cache:
587 new_result = '_'+`self.prompt_count`
594 new_result = '_'+`self.prompt_count`
588 to_main[new_result] = arg
595 to_main[new_result] = arg
589 self.user_ns.update(to_main)
596 self.user_ns.update(to_main)
590 self.user_ns['_oh'][self.prompt_count] = arg
597 self.user_ns['_oh'][self.prompt_count] = arg
591
598
592 def flush(self):
599 def flush(self):
593 if not self.do_full_cache:
600 if not self.do_full_cache:
594 raise ValueError,"You shouldn't have reached the cache flush "\
601 raise ValueError,"You shouldn't have reached the cache flush "\
595 "if full caching is not enabled!"
602 "if full caching is not enabled!"
596 # delete auto-generated vars from global namespace
603 # delete auto-generated vars from global namespace
597
604
598 for n in range(1,self.prompt_count + 1):
605 for n in range(1,self.prompt_count + 1):
599 key = '_'+`n`
606 key = '_'+`n`
600 try:
607 try:
601 del self.user_ns[key]
608 del self.user_ns[key]
602 except: pass
609 except: pass
603 self.user_ns['_oh'].clear()
610 self.user_ns['_oh'].clear()
604
611
605 if '_' not in __builtin__.__dict__:
612 if '_' not in __builtin__.__dict__:
606 self.user_ns.update({'_':None,'__':None, '___':None})
613 self.user_ns.update({'_':None,'__':None, '___':None})
607 import gc
614 import gc
608 gc.collect() # xxx needed?
615 gc.collect() # xxx needed?
609
616
@@ -1,217 +1,215
1 """hooks for IPython.
1 """hooks for IPython.
2
2
3 In Python, it is possible to overwrite any method of any object if you really
3 In Python, it is possible to overwrite any method of any object if you really
4 want to. But IPython exposes a few 'hooks', methods which are _designed_ to
4 want to. But IPython exposes a few 'hooks', methods which are _designed_ to
5 be overwritten by users for customization purposes. This module defines the
5 be overwritten by users for customization purposes. This module defines the
6 default versions of all such hooks, which get used by IPython if not
6 default versions of all such hooks, which get used by IPython if not
7 overridden by the user.
7 overridden by the user.
8
8
9 hooks are simple functions, but they should be declared with 'self' as their
9 hooks are simple functions, but they should be declared with 'self' as their
10 first argument, because when activated they are registered into IPython as
10 first argument, because when activated they are registered into IPython as
11 instance methods. The self argument will be the IPython running instance
11 instance methods. The self argument will be the IPython running instance
12 itself, so hooks have full access to the entire IPython object.
12 itself, so hooks have full access to the entire IPython object.
13
13
14 If you wish to define a new hook and activate it, you need to put the
14 If you wish to define a new hook and activate it, you need to put the
15 necessary code into a python file which can be either imported or execfile()'d
15 necessary code into a python file which can be either imported or execfile()'d
16 from within your ipythonrc configuration.
16 from within your ipythonrc configuration.
17
17
18 For example, suppose that you have a module called 'myiphooks' in your
18 For example, suppose that you have a module called 'myiphooks' in your
19 PYTHONPATH, which contains the following definition:
19 PYTHONPATH, which contains the following definition:
20
20
21 import os
21 import os
22 import IPython.ipapi
22 import IPython.ipapi
23 ip = IPython.ipapi.get()
23 ip = IPython.ipapi.get()
24
24
25 def calljed(self,filename, linenum):
25 def calljed(self,filename, linenum):
26 "My editor hook calls the jed editor directly."
26 "My editor hook calls the jed editor directly."
27 print "Calling my own editor, jed ..."
27 print "Calling my own editor, jed ..."
28 os.system('jed +%d %s' % (linenum,filename))
28 os.system('jed +%d %s' % (linenum,filename))
29
29
30 ip.set_hook('editor', calljed)
30 ip.set_hook('editor', calljed)
31
31
32 You can then enable the functionality by doing 'import myiphooks'
32 You can then enable the functionality by doing 'import myiphooks'
33 somewhere in your configuration files or ipython command line.
33 somewhere in your configuration files or ipython command line.
34
34
35 $Id: hooks.py 1854 2006-10-30 19:54:25Z vivainio $"""
35 $Id: hooks.py 2899 2007-12-28 08:32:59Z fperez $"""
36
36
37 #*****************************************************************************
37 #*****************************************************************************
38 # Copyright (C) 2005 Fernando Perez. <fperez@colorado.edu>
38 # Copyright (C) 2005 Fernando Perez. <fperez@colorado.edu>
39 #
39 #
40 # Distributed under the terms of the BSD License. The full license is in
40 # Distributed under the terms of the BSD License. The full license is in
41 # the file COPYING, distributed as part of this software.
41 # the file COPYING, distributed as part of this software.
42 #*****************************************************************************
42 #*****************************************************************************
43
43
44 from IPython import Release
44 from IPython import Release
45 from IPython import ipapi
45 from IPython import ipapi
46 __author__ = '%s <%s>' % Release.authors['Fernando']
46 __author__ = '%s <%s>' % Release.authors['Fernando']
47 __license__ = Release.license
47 __license__ = Release.license
48 __version__ = Release.version
48 __version__ = Release.version
49
49
50 import os,bisect
50 import os,bisect
51 from genutils import Term
51 from genutils import Term
52 from pprint import PrettyPrinter
52 from pprint import PrettyPrinter
53
53
54 # List here all the default hooks. For now it's just the editor functions
54 # List here all the default hooks. For now it's just the editor functions
55 # but over time we'll move here all the public API for user-accessible things.
55 # but over time we'll move here all the public API for user-accessible things.
56 __all__ = ['editor', 'fix_error_editor', 'result_display',
56 __all__ = ['editor', 'fix_error_editor', 'result_display',
57 'input_prefilter', 'shutdown_hook', 'late_startup_hook',
57 'input_prefilter', 'shutdown_hook', 'late_startup_hook',
58 'generate_prompt', 'generate_output_prompt' ]
58 'generate_prompt', 'generate_output_prompt' ]
59
59
60 pformat = PrettyPrinter().pformat
60 pformat = PrettyPrinter().pformat
61
61
62 def editor(self,filename, linenum=None):
62 def editor(self,filename, linenum=None):
63 """Open the default editor at the given filename and linenumber.
63 """Open the default editor at the given filename and linenumber.
64
64
65 This is IPython's default editor hook, you can use it as an example to
65 This is IPython's default editor hook, you can use it as an example to
66 write your own modified one. To set your own editor function as the
66 write your own modified one. To set your own editor function as the
67 new editor hook, call ip.set_hook('editor',yourfunc)."""
67 new editor hook, call ip.set_hook('editor',yourfunc)."""
68
68
69 # IPython configures a default editor at startup by reading $EDITOR from
69 # IPython configures a default editor at startup by reading $EDITOR from
70 # the environment, and falling back on vi (unix) or notepad (win32).
70 # the environment, and falling back on vi (unix) or notepad (win32).
71 editor = self.rc.editor
71 editor = self.rc.editor
72
72
73 # marker for at which line to open the file (for existing objects)
73 # marker for at which line to open the file (for existing objects)
74 if linenum is None or editor=='notepad':
74 if linenum is None or editor=='notepad':
75 linemark = ''
75 linemark = ''
76 else:
76 else:
77 linemark = '+%d' % int(linenum)
77 linemark = '+%d' % int(linenum)
78
78
79 # Enclose in quotes if necessary and legal
79 # Enclose in quotes if necessary and legal
80 if ' ' in editor and os.path.isfile(editor) and editor[0] != '"':
80 if ' ' in editor and os.path.isfile(editor) and editor[0] != '"':
81 editor = '"%s"' % editor
81 editor = '"%s"' % editor
82
82
83 # Call the actual editor
83 # Call the actual editor
84 os.system('%s %s %s' % (editor,linemark,filename))
84 os.system('%s %s %s' % (editor,linemark,filename))
85
85
86 import tempfile
86 import tempfile
87 def fix_error_editor(self,filename,linenum,column,msg):
87 def fix_error_editor(self,filename,linenum,column,msg):
88 """Open the editor at the given filename, linenumber, column and
88 """Open the editor at the given filename, linenumber, column and
89 show an error message. This is used for correcting syntax errors.
89 show an error message. This is used for correcting syntax errors.
90 The current implementation only has special support for the VIM editor,
90 The current implementation only has special support for the VIM editor,
91 and falls back on the 'editor' hook if VIM is not used.
91 and falls back on the 'editor' hook if VIM is not used.
92
92
93 Call ip.set_hook('fix_error_editor',youfunc) to use your own function,
93 Call ip.set_hook('fix_error_editor',youfunc) to use your own function,
94 """
94 """
95 def vim_quickfix_file():
95 def vim_quickfix_file():
96 t = tempfile.NamedTemporaryFile()
96 t = tempfile.NamedTemporaryFile()
97 t.write('%s:%d:%d:%s\n' % (filename,linenum,column,msg))
97 t.write('%s:%d:%d:%s\n' % (filename,linenum,column,msg))
98 t.flush()
98 t.flush()
99 return t
99 return t
100 if os.path.basename(self.rc.editor) != 'vim':
100 if os.path.basename(self.rc.editor) != 'vim':
101 self.hooks.editor(filename,linenum)
101 self.hooks.editor(filename,linenum)
102 return
102 return
103 t = vim_quickfix_file()
103 t = vim_quickfix_file()
104 try:
104 try:
105 os.system('vim --cmd "set errorformat=%f:%l:%c:%m" -q ' + t.name)
105 os.system('vim --cmd "set errorformat=%f:%l:%c:%m" -q ' + t.name)
106 finally:
106 finally:
107 t.close()
107 t.close()
108
108
109
109
110 class CommandChainDispatcher:
110 class CommandChainDispatcher:
111 """ Dispatch calls to a chain of commands until some func can handle it
111 """ Dispatch calls to a chain of commands until some func can handle it
112
112
113 Usage: instantiate, execute "add" to add commands (with optional
113 Usage: instantiate, execute "add" to add commands (with optional
114 priority), execute normally via f() calling mechanism.
114 priority), execute normally via f() calling mechanism.
115
115
116 """
116 """
117 def __init__(self,commands=None):
117 def __init__(self,commands=None):
118 if commands is None:
118 if commands is None:
119 self.chain = []
119 self.chain = []
120 else:
120 else:
121 self.chain = commands
121 self.chain = commands
122
122
123
123
124 def __call__(self,*args, **kw):
124 def __call__(self,*args, **kw):
125 """ Command chain is called just like normal func.
125 """ Command chain is called just like normal func.
126
126
127 This will call all funcs in chain with the same args as were given to this
127 This will call all funcs in chain with the same args as were given to this
128 function, and return the result of first func that didn't raise
128 function, and return the result of first func that didn't raise
129 TryNext """
129 TryNext """
130
130
131 for prio,cmd in self.chain:
131 for prio,cmd in self.chain:
132 #print "prio",prio,"cmd",cmd #dbg
132 #print "prio",prio,"cmd",cmd #dbg
133 try:
133 try:
134 ret = cmd(*args, **kw)
134 ret = cmd(*args, **kw)
135 return ret
135 return ret
136 except ipapi.TryNext, exc:
136 except ipapi.TryNext, exc:
137 if exc.args or exc.kwargs:
137 if exc.args or exc.kwargs:
138 args = exc.args
138 args = exc.args
139 kw = exc.kwargs
139 kw = exc.kwargs
140
140
141 def __str__(self):
141 def __str__(self):
142 return str(self.chain)
142 return str(self.chain)
143
143
144 def add(self, func, priority=0):
144 def add(self, func, priority=0):
145 """ Add a func to the cmd chain with given priority """
145 """ Add a func to the cmd chain with given priority """
146 bisect.insort(self.chain,(priority,func))
146 bisect.insort(self.chain,(priority,func))
147
147
148 def __iter__(self):
148 def __iter__(self):
149 """ Return all objects in chain.
149 """ Return all objects in chain.
150
150
151 Handy if the objects are not callable.
151 Handy if the objects are not callable.
152 """
152 """
153 return iter(self.chain)
153 return iter(self.chain)
154
154
155 def result_display(self,arg):
155 def result_display(self,arg):
156 """ Default display hook.
156 """ Default display hook.
157
157
158 Called for displaying the result to the user.
158 Called for displaying the result to the user.
159 """
159 """
160
160
161 if self.rc.pprint:
161 if self.rc.pprint:
162 out = pformat(arg)
162 out = pformat(arg)
163 if '\n' in out:
163 if '\n' in out:
164 # So that multi-line strings line up with the left column of
164 # So that multi-line strings line up with the left column of
165 # the screen, instead of having the output prompt mess up
165 # the screen, instead of having the output prompt mess up
166 # their first line.
166 # their first line.
167 Term.cout.write('\n')
167 Term.cout.write('\n')
168 print >>Term.cout, out
168 print >>Term.cout, out
169 else:
169 else:
170 # By default, the interactive prompt uses repr() to display results,
170 # By default, the interactive prompt uses repr() to display results,
171 # so we should honor this. Users who'd rather use a different
171 # so we should honor this. Users who'd rather use a different
172 # mechanism can easily override this hook.
172 # mechanism can easily override this hook.
173 print >>Term.cout, repr(arg)
173 print >>Term.cout, repr(arg)
174 # the default display hook doesn't manipulate the value to put in history
174 # the default display hook doesn't manipulate the value to put in history
175 return None
175 return None
176
176
177 def input_prefilter(self,line):
177 def input_prefilter(self,line):
178 """ Default input prefilter
178 """ Default input prefilter
179
179
180 This returns the line as unchanged, so that the interpreter
180 This returns the line as unchanged, so that the interpreter
181 knows that nothing was done and proceeds with "classic" prefiltering
181 knows that nothing was done and proceeds with "classic" prefiltering
182 (%magics, !shell commands etc.).
182 (%magics, !shell commands etc.).
183
183
184 Note that leading whitespace is not passed to this hook. Prefilter
184 Note that leading whitespace is not passed to this hook. Prefilter
185 can't alter indentation.
185 can't alter indentation.
186
186
187 """
187 """
188 #print "attempt to rewrite",line #dbg
188 #print "attempt to rewrite",line #dbg
189 return line
189 return line
190
190
191 def shutdown_hook(self):
191 def shutdown_hook(self):
192 """ default shutdown hook
192 """ default shutdown hook
193
193
194 Typically, shotdown hooks should raise TryNext so all shutdown ops are done
194 Typically, shotdown hooks should raise TryNext so all shutdown ops are done
195 """
195 """
196
196
197 #print "default shutdown hook ok" # dbg
197 #print "default shutdown hook ok" # dbg
198 return
198 return
199
199
200 def late_startup_hook(self):
200 def late_startup_hook(self):
201 """ Executed after ipython has been constructed and configured
201 """ Executed after ipython has been constructed and configured
202
202
203 """
203 """
204 #print "default startup hook ok" # dbg
204 #print "default startup hook ok" # dbg
205
205
206 def generate_prompt(self, is_continuation):
206 def generate_prompt(self, is_continuation):
207 """ calculate and return a string with the prompt to display """
207 """ calculate and return a string with the prompt to display """
208 ip = self.api
208 ip = self.api
209 if is_continuation:
209 if is_continuation:
210 return str(ip.IP.outputcache.prompt2)
210 return str(ip.IP.outputcache.prompt2)
211 return str(ip.IP.outputcache.prompt1)
211 return str(ip.IP.outputcache.prompt1)
212
212
213 def generate_output_prompt(self):
213 def generate_output_prompt(self):
214 ip = self.api
214 ip = self.api
215 return str(ip.IP.outputcache.prompt_out)
215 return str(ip.IP.outputcache.prompt_out)
216
217 No newline at end of file
@@ -1,2580 +1,2584
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.3 or newer.
5 Requires Python 2.3 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 2894 2007-12-13 20:34:23Z vivainio $
9 $Id: iplib.py 2899 2007-12-28 08:32:59Z 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-2006 Fernando Perez. <fperez@colorado.edu>
14 # Copyright (C) 2001-2006 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 IPython import Release
31 from IPython import Release
32 __author__ = '%s <%s>\n%s <%s>' % \
32 __author__ = '%s <%s>\n%s <%s>' % \
33 ( Release.authors['Janko'] + Release.authors['Fernando'] )
33 ( Release.authors['Janko'] + Release.authors['Fernando'] )
34 __license__ = Release.license
34 __license__ = Release.license
35 __version__ = Release.version
35 __version__ = Release.version
36
36
37 # Python standard modules
37 # Python standard modules
38 import __main__
38 import __main__
39 import __builtin__
39 import __builtin__
40 import StringIO
40 import StringIO
41 import bdb
41 import bdb
42 import cPickle as pickle
42 import cPickle as pickle
43 import codeop
43 import codeop
44 import exceptions
44 import exceptions
45 import glob
45 import glob
46 import inspect
46 import inspect
47 import keyword
47 import keyword
48 import new
48 import new
49 import os
49 import os
50 import pydoc
50 import pydoc
51 import re
51 import re
52 import shutil
52 import shutil
53 import string
53 import string
54 import sys
54 import sys
55 import tempfile
55 import tempfile
56 import traceback
56 import traceback
57 import types
57 import types
58 from sets import Set
58 from sets import Set
59 from pprint import pprint, pformat
59 from pprint import pprint, pformat
60
60
61 # IPython's own modules
61 # IPython's own modules
62 #import IPython
62 #import IPython
63 from IPython import Debugger,OInspect,PyColorize,ultraTB
63 from IPython import Debugger,OInspect,PyColorize,ultraTB
64 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
64 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
65 from IPython.Extensions import pickleshare
65 from IPython.Extensions import pickleshare
66 from IPython.FakeModule import FakeModule
66 from IPython.FakeModule import FakeModule
67 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
67 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
68 from IPython.Logger import Logger
68 from IPython.Logger import Logger
69 from IPython.Magic import Magic
69 from IPython.Magic import Magic
70 from IPython.Prompts import CachedOutput
70 from IPython.Prompts import CachedOutput
71 from IPython.ipstruct import Struct
71 from IPython.ipstruct import Struct
72 from IPython.background_jobs import BackgroundJobManager
72 from IPython.background_jobs import BackgroundJobManager
73 from IPython.usage import cmd_line_usage,interactive_usage
73 from IPython.usage import cmd_line_usage,interactive_usage
74 from IPython.genutils import *
74 from IPython.genutils import *
75 from IPython.strdispatch import StrDispatch
75 from IPython.strdispatch import StrDispatch
76 import IPython.ipapi
76 import IPython.ipapi
77 import IPython.history
77 import IPython.history
78 import IPython.prefilter as prefilter
78 import IPython.prefilter as prefilter
79 import IPython.shadowns
79 import IPython.shadowns
80 # Globals
80 # Globals
81
81
82 # store the builtin raw_input globally, and use this always, in case user code
82 # store the builtin raw_input globally, and use this always, in case user code
83 # overwrites it (like wx.py.PyShell does)
83 # overwrites it (like wx.py.PyShell does)
84 raw_input_original = raw_input
84 raw_input_original = raw_input
85
85
86 # compiled regexps for autoindent management
86 # compiled regexps for autoindent management
87 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
87 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
88
88
89
89
90 #****************************************************************************
90 #****************************************************************************
91 # Some utility function definitions
91 # Some utility function definitions
92
92
93 ini_spaces_re = re.compile(r'^(\s+)')
93 ini_spaces_re = re.compile(r'^(\s+)')
94
94
95 def num_ini_spaces(strng):
95 def num_ini_spaces(strng):
96 """Return the number of initial spaces in a string"""
96 """Return the number of initial spaces in a string"""
97
97
98 ini_spaces = ini_spaces_re.match(strng)
98 ini_spaces = ini_spaces_re.match(strng)
99 if ini_spaces:
99 if ini_spaces:
100 return ini_spaces.end()
100 return ini_spaces.end()
101 else:
101 else:
102 return 0
102 return 0
103
103
104 def softspace(file, newvalue):
104 def softspace(file, newvalue):
105 """Copied from code.py, to remove the dependency"""
105 """Copied from code.py, to remove the dependency"""
106
106
107 oldvalue = 0
107 oldvalue = 0
108 try:
108 try:
109 oldvalue = file.softspace
109 oldvalue = file.softspace
110 except AttributeError:
110 except AttributeError:
111 pass
111 pass
112 try:
112 try:
113 file.softspace = newvalue
113 file.softspace = newvalue
114 except (AttributeError, TypeError):
114 except (AttributeError, TypeError):
115 # "attribute-less object" or "read-only attributes"
115 # "attribute-less object" or "read-only attributes"
116 pass
116 pass
117 return oldvalue
117 return oldvalue
118
118
119
119
120 #****************************************************************************
120 #****************************************************************************
121 # Local use exceptions
121 # Local use exceptions
122 class SpaceInInput(exceptions.Exception): pass
122 class SpaceInInput(exceptions.Exception): pass
123
123
124
124
125 #****************************************************************************
125 #****************************************************************************
126 # Local use classes
126 # Local use classes
127 class Bunch: pass
127 class Bunch: pass
128
128
129 class Undefined: pass
129 class Undefined: pass
130
130
131 class Quitter(object):
131 class Quitter(object):
132 """Simple class to handle exit, similar to Python 2.5's.
132 """Simple class to handle exit, similar to Python 2.5's.
133
133
134 It handles exiting in an ipython-safe manner, which the one in Python 2.5
134 It handles exiting in an ipython-safe manner, which the one in Python 2.5
135 doesn't do (obviously, since it doesn't know about ipython)."""
135 doesn't do (obviously, since it doesn't know about ipython)."""
136
136
137 def __init__(self,shell,name):
137 def __init__(self,shell,name):
138 self.shell = shell
138 self.shell = shell
139 self.name = name
139 self.name = name
140
140
141 def __repr__(self):
141 def __repr__(self):
142 return 'Type %s() to exit.' % self.name
142 return 'Type %s() to exit.' % self.name
143 __str__ = __repr__
143 __str__ = __repr__
144
144
145 def __call__(self):
145 def __call__(self):
146 self.shell.exit()
146 self.shell.exit()
147
147
148 class InputList(list):
148 class InputList(list):
149 """Class to store user input.
149 """Class to store user input.
150
150
151 It's basically a list, but slices return a string instead of a list, thus
151 It's basically a list, but slices return a string instead of a list, thus
152 allowing things like (assuming 'In' is an instance):
152 allowing things like (assuming 'In' is an instance):
153
153
154 exec In[4:7]
154 exec In[4:7]
155
155
156 or
156 or
157
157
158 exec In[5:9] + In[14] + In[21:25]"""
158 exec In[5:9] + In[14] + In[21:25]"""
159
159
160 def __getslice__(self,i,j):
160 def __getslice__(self,i,j):
161 return ''.join(list.__getslice__(self,i,j))
161 return ''.join(list.__getslice__(self,i,j))
162
162
163 class SyntaxTB(ultraTB.ListTB):
163 class SyntaxTB(ultraTB.ListTB):
164 """Extension which holds some state: the last exception value"""
164 """Extension which holds some state: the last exception value"""
165
165
166 def __init__(self,color_scheme = 'NoColor'):
166 def __init__(self,color_scheme = 'NoColor'):
167 ultraTB.ListTB.__init__(self,color_scheme)
167 ultraTB.ListTB.__init__(self,color_scheme)
168 self.last_syntax_error = None
168 self.last_syntax_error = None
169
169
170 def __call__(self, etype, value, elist):
170 def __call__(self, etype, value, elist):
171 self.last_syntax_error = value
171 self.last_syntax_error = value
172 ultraTB.ListTB.__call__(self,etype,value,elist)
172 ultraTB.ListTB.__call__(self,etype,value,elist)
173
173
174 def clear_err_state(self):
174 def clear_err_state(self):
175 """Return the current error state and clear it"""
175 """Return the current error state and clear it"""
176 e = self.last_syntax_error
176 e = self.last_syntax_error
177 self.last_syntax_error = None
177 self.last_syntax_error = None
178 return e
178 return e
179
179
180 #****************************************************************************
180 #****************************************************************************
181 # Main IPython class
181 # Main IPython class
182
182
183 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
183 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
184 # until a full rewrite is made. I've cleaned all cross-class uses of
184 # until a full rewrite is made. I've cleaned all cross-class uses of
185 # attributes and methods, but too much user code out there relies on the
185 # attributes and methods, but too much user code out there relies on the
186 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
186 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
187 #
187 #
188 # But at least now, all the pieces have been separated and we could, in
188 # But at least now, all the pieces have been separated and we could, in
189 # principle, stop using the mixin. This will ease the transition to the
189 # principle, stop using the mixin. This will ease the transition to the
190 # chainsaw branch.
190 # chainsaw branch.
191
191
192 # For reference, the following is the list of 'self.foo' uses in the Magic
192 # For reference, the following is the list of 'self.foo' uses in the Magic
193 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
193 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
194 # class, to prevent clashes.
194 # class, to prevent clashes.
195
195
196 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
196 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
197 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
197 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
198 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
198 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
199 # 'self.value']
199 # 'self.value']
200
200
201 class InteractiveShell(object,Magic):
201 class InteractiveShell(object,Magic):
202 """An enhanced console for Python."""
202 """An enhanced console for Python."""
203
203
204 # class attribute to indicate whether the class supports threads or not.
204 # class attribute to indicate whether the class supports threads or not.
205 # Subclasses with thread support should override this as needed.
205 # Subclasses with thread support should override this as needed.
206 isthreaded = False
206 isthreaded = False
207
207
208 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
208 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
209 user_ns = None,user_global_ns=None,banner2='',
209 user_ns = None,user_global_ns=None,banner2='',
210 custom_exceptions=((),None),embedded=False):
210 custom_exceptions=((),None),embedded=False):
211
211
212 # log system
212 # log system
213 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
213 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
214
214
215 # some minimal strict typechecks. For some core data structures, I
215 # some minimal strict typechecks. For some core data structures, I
216 # want actual basic python types, not just anything that looks like
216 # want actual basic python types, not just anything that looks like
217 # one. This is especially true for namespaces.
217 # one. This is especially true for namespaces.
218 for ns in (user_ns,user_global_ns):
218 for ns in (user_ns,user_global_ns):
219 if ns is not None and type(ns) != types.DictType:
219 if ns is not None and type(ns) != types.DictType:
220 raise TypeError,'namespace must be a dictionary'
220 raise TypeError,'namespace must be a dictionary'
221
221
222 # Job manager (for jobs run as background threads)
222 # Job manager (for jobs run as background threads)
223 self.jobs = BackgroundJobManager()
223 self.jobs = BackgroundJobManager()
224
224
225 # Store the actual shell's name
225 # Store the actual shell's name
226 self.name = name
226 self.name = name
227
227
228 # We need to know whether the instance is meant for embedding, since
228 # We need to know whether the instance is meant for embedding, since
229 # global/local namespaces need to be handled differently in that case
229 # global/local namespaces need to be handled differently in that case
230 self.embedded = embedded
230 self.embedded = embedded
231 if embedded:
231 if embedded:
232 # Control variable so users can, from within the embedded instance,
232 # Control variable so users can, from within the embedded instance,
233 # permanently deactivate it.
233 # permanently deactivate it.
234 self.embedded_active = True
234 self.embedded_active = True
235
235
236 # command compiler
236 # command compiler
237 self.compile = codeop.CommandCompiler()
237 self.compile = codeop.CommandCompiler()
238
238
239 # User input buffer
239 # User input buffer
240 self.buffer = []
240 self.buffer = []
241
241
242 # Default name given in compilation of code
242 # Default name given in compilation of code
243 self.filename = '<ipython console>'
243 self.filename = '<ipython console>'
244
244
245 # Install our own quitter instead of the builtins. For python2.3-2.4,
245 # Install our own quitter instead of the builtins. For python2.3-2.4,
246 # this brings in behavior like 2.5, and for 2.5 it's identical.
246 # this brings in behavior like 2.5, and for 2.5 it's identical.
247 __builtin__.exit = Quitter(self,'exit')
247 __builtin__.exit = Quitter(self,'exit')
248 __builtin__.quit = Quitter(self,'quit')
248 __builtin__.quit = Quitter(self,'quit')
249
249
250 # Make an empty namespace, which extension writers can rely on both
250 # Make an empty namespace, which extension writers can rely on both
251 # existing and NEVER being used by ipython itself. This gives them a
251 # existing and NEVER being used by ipython itself. This gives them a
252 # convenient location for storing additional information and state
252 # convenient location for storing additional information and state
253 # their extensions may require, without fear of collisions with other
253 # their extensions may require, without fear of collisions with other
254 # ipython names that may develop later.
254 # ipython names that may develop later.
255 self.meta = Struct()
255 self.meta = Struct()
256
256
257 # Create the namespace where the user will operate. user_ns is
257 # Create the namespace where the user will operate. user_ns is
258 # normally the only one used, and it is passed to the exec calls as
258 # normally the only one used, and it is passed to the exec calls as
259 # the locals argument. But we do carry a user_global_ns namespace
259 # the locals argument. But we do carry a user_global_ns namespace
260 # given as the exec 'globals' argument, This is useful in embedding
260 # given as the exec 'globals' argument, This is useful in embedding
261 # situations where the ipython shell opens in a context where the
261 # situations where the ipython shell opens in a context where the
262 # distinction between locals and globals is meaningful.
262 # distinction between locals and globals is meaningful.
263
263
264 # FIXME. For some strange reason, __builtins__ is showing up at user
264 # FIXME. For some strange reason, __builtins__ is showing up at user
265 # level as a dict instead of a module. This is a manual fix, but I
265 # level as a dict instead of a module. This is a manual fix, but I
266 # should really track down where the problem is coming from. Alex
266 # should really track down where the problem is coming from. Alex
267 # Schmolck reported this problem first.
267 # Schmolck reported this problem first.
268
268
269 # A useful post by Alex Martelli on this topic:
269 # A useful post by Alex Martelli on this topic:
270 # Re: inconsistent value from __builtins__
270 # Re: inconsistent value from __builtins__
271 # Von: Alex Martelli <aleaxit@yahoo.com>
271 # Von: Alex Martelli <aleaxit@yahoo.com>
272 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
272 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
273 # Gruppen: comp.lang.python
273 # Gruppen: comp.lang.python
274
274
275 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
275 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
276 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
276 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
277 # > <type 'dict'>
277 # > <type 'dict'>
278 # > >>> print type(__builtins__)
278 # > >>> print type(__builtins__)
279 # > <type 'module'>
279 # > <type 'module'>
280 # > Is this difference in return value intentional?
280 # > Is this difference in return value intentional?
281
281
282 # Well, it's documented that '__builtins__' can be either a dictionary
282 # Well, it's documented that '__builtins__' can be either a dictionary
283 # or a module, and it's been that way for a long time. Whether it's
283 # or a module, and it's been that way for a long time. Whether it's
284 # intentional (or sensible), I don't know. In any case, the idea is
284 # intentional (or sensible), I don't know. In any case, the idea is
285 # that if you need to access the built-in namespace directly, you
285 # that if you need to access the built-in namespace directly, you
286 # should start with "import __builtin__" (note, no 's') which will
286 # should start with "import __builtin__" (note, no 's') which will
287 # definitely give you a module. Yeah, it's somewhat confusing:-(.
287 # definitely give you a module. Yeah, it's somewhat confusing:-(.
288
288
289 # These routines return properly built dicts as needed by the rest of
289 # These routines return properly built dicts as needed by the rest of
290 # the code, and can also be used by extension writers to generate
290 # the code, and can also be used by extension writers to generate
291 # properly initialized namespaces.
291 # properly initialized namespaces.
292 user_ns = IPython.ipapi.make_user_ns(user_ns)
292 user_ns = IPython.ipapi.make_user_ns(user_ns)
293 user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
293 user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
294
294
295 # Assign namespaces
295 # Assign namespaces
296 # This is the namespace where all normal user variables live
296 # This is the namespace where all normal user variables live
297 self.user_ns = user_ns
297 self.user_ns = user_ns
298 # Embedded instances require a separate namespace for globals.
298 # Embedded instances require a separate namespace for globals.
299 # Normally this one is unused by non-embedded instances.
299 # Normally this one is unused by non-embedded instances.
300 self.user_global_ns = user_global_ns
300 self.user_global_ns = user_global_ns
301 # A namespace to keep track of internal data structures to prevent
301 # A namespace to keep track of internal data structures to prevent
302 # them from cluttering user-visible stuff. Will be updated later
302 # them from cluttering user-visible stuff. Will be updated later
303 self.internal_ns = {}
303 self.internal_ns = {}
304
304
305 # Namespace of system aliases. Each entry in the alias
305 # Namespace of system aliases. Each entry in the alias
306 # table must be a 2-tuple of the form (N,name), where N is the number
306 # table must be a 2-tuple of the form (N,name), where N is the number
307 # of positional arguments of the alias.
307 # of positional arguments of the alias.
308 self.alias_table = {}
308 self.alias_table = {}
309
309
310 # A table holding all the namespaces IPython deals with, so that
310 # A table holding all the namespaces IPython deals with, so that
311 # introspection facilities can search easily.
311 # introspection facilities can search easily.
312 self.ns_table = {'user':user_ns,
312 self.ns_table = {'user':user_ns,
313 'user_global':user_global_ns,
313 'user_global':user_global_ns,
314 'alias':self.alias_table,
314 'alias':self.alias_table,
315 'internal':self.internal_ns,
315 'internal':self.internal_ns,
316 'builtin':__builtin__.__dict__
316 'builtin':__builtin__.__dict__
317 }
317 }
318 # The user namespace MUST have a pointer to the shell itself.
318 # The user namespace MUST have a pointer to the shell itself.
319 self.user_ns[name] = self
319 self.user_ns[name] = self
320
320
321 # We need to insert into sys.modules something that looks like a
321 # We need to insert into sys.modules something that looks like a
322 # module but which accesses the IPython namespace, for shelve and
322 # module but which accesses the IPython namespace, for shelve and
323 # pickle to work interactively. Normally they rely on getting
323 # pickle to work interactively. Normally they rely on getting
324 # everything out of __main__, but for embedding purposes each IPython
324 # everything out of __main__, but for embedding purposes each IPython
325 # instance has its own private namespace, so we can't go shoving
325 # instance has its own private namespace, so we can't go shoving
326 # everything into __main__.
326 # everything into __main__.
327
327
328 # note, however, that we should only do this for non-embedded
328 # note, however, that we should only do this for non-embedded
329 # ipythons, which really mimic the __main__.__dict__ with their own
329 # ipythons, which really mimic the __main__.__dict__ with their own
330 # namespace. Embedded instances, on the other hand, should not do
330 # namespace. Embedded instances, on the other hand, should not do
331 # this because they need to manage the user local/global namespaces
331 # this because they need to manage the user local/global namespaces
332 # only, but they live within a 'normal' __main__ (meaning, they
332 # only, but they live within a 'normal' __main__ (meaning, they
333 # shouldn't overtake the execution environment of the script they're
333 # shouldn't overtake the execution environment of the script they're
334 # embedded in).
334 # embedded in).
335
335
336 if not embedded:
336 if not embedded:
337 try:
337 try:
338 main_name = self.user_ns['__name__']
338 main_name = self.user_ns['__name__']
339 except KeyError:
339 except KeyError:
340 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
340 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
341 else:
341 else:
342 #print "pickle hack in place" # dbg
342 #print "pickle hack in place" # dbg
343 #print 'main_name:',main_name # dbg
343 #print 'main_name:',main_name # dbg
344 sys.modules[main_name] = FakeModule(self.user_ns)
344 sys.modules[main_name] = FakeModule(self.user_ns)
345
345
346 # Now that FakeModule produces a real module, we've run into a nasty
346 # Now that FakeModule produces a real module, we've run into a nasty
347 # problem: after script execution (via %run), the module where the user
347 # problem: after script execution (via %run), the module where the user
348 # code ran is deleted. Now that this object is a true module (needed
348 # code ran is deleted. Now that this object is a true module (needed
349 # so docetst and other tools work correctly), the Python module
349 # so docetst and other tools work correctly), the Python module
350 # teardown mechanism runs over it, and sets to None every variable
350 # teardown mechanism runs over it, and sets to None every variable
351 # present in that module. This means that later calls to functions
351 # present in that module. This means that later calls to functions
352 # defined in the script (which have become interactively visible after
352 # defined in the script (which have become interactively visible after
353 # script exit) fail, because they hold references to objects that have
353 # script exit) fail, because they hold references to objects that have
354 # become overwritten into None. The only solution I see right now is
354 # become overwritten into None. The only solution I see right now is
355 # to protect every FakeModule used by %run by holding an internal
355 # to protect every FakeModule used by %run by holding an internal
356 # reference to it. This private list will be used for that. The
356 # reference to it. This private list will be used for that. The
357 # %reset command will flush it as well.
357 # %reset command will flush it as well.
358 self._user_main_modules = []
358 self._user_main_modules = []
359
359
360 # List of input with multi-line handling.
360 # List of input with multi-line handling.
361 # Fill its zero entry, user counter starts at 1
361 # Fill its zero entry, user counter starts at 1
362 self.input_hist = InputList(['\n'])
362 self.input_hist = InputList(['\n'])
363 # This one will hold the 'raw' input history, without any
363 # This one will hold the 'raw' input history, without any
364 # pre-processing. This will allow users to retrieve the input just as
364 # pre-processing. This will allow users to retrieve the input just as
365 # it was exactly typed in by the user, with %hist -r.
365 # it was exactly typed in by the user, with %hist -r.
366 self.input_hist_raw = InputList(['\n'])
366 self.input_hist_raw = InputList(['\n'])
367
367
368 # list of visited directories
368 # list of visited directories
369 try:
369 try:
370 self.dir_hist = [os.getcwd()]
370 self.dir_hist = [os.getcwd()]
371 except OSError:
371 except OSError:
372 self.dir_hist = []
372 self.dir_hist = []
373
373
374 # dict of output history
374 # dict of output history
375 self.output_hist = {}
375 self.output_hist = {}
376
376
377 # Get system encoding at startup time. Certain terminals (like Emacs
377 # Get system encoding at startup time. Certain terminals (like Emacs
378 # under Win32 have it set to None, and we need to have a known valid
378 # under Win32 have it set to None, and we need to have a known valid
379 # encoding to use in the raw_input() method
379 # encoding to use in the raw_input() method
380 self.stdin_encoding = sys.stdin.encoding or 'ascii'
380 self.stdin_encoding = sys.stdin.encoding or 'ascii'
381
381
382 # dict of things NOT to alias (keywords, builtins and some magics)
382 # dict of things NOT to alias (keywords, builtins and some magics)
383 no_alias = {}
383 no_alias = {}
384 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
384 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
385 for key in keyword.kwlist + no_alias_magics:
385 for key in keyword.kwlist + no_alias_magics:
386 no_alias[key] = 1
386 no_alias[key] = 1
387 no_alias.update(__builtin__.__dict__)
387 no_alias.update(__builtin__.__dict__)
388 self.no_alias = no_alias
388 self.no_alias = no_alias
389
389
390 # make global variables for user access to these
390 # make global variables for user access to these
391 self.user_ns['_ih'] = self.input_hist
391 self.user_ns['_ih'] = self.input_hist
392 self.user_ns['_oh'] = self.output_hist
392 self.user_ns['_oh'] = self.output_hist
393 self.user_ns['_dh'] = self.dir_hist
393 self.user_ns['_dh'] = self.dir_hist
394
394
395 # user aliases to input and output histories
395 # user aliases to input and output histories
396 self.user_ns['In'] = self.input_hist
396 self.user_ns['In'] = self.input_hist
397 self.user_ns['Out'] = self.output_hist
397 self.user_ns['Out'] = self.output_hist
398
398
399 self.user_ns['_sh'] = IPython.shadowns
399 self.user_ns['_sh'] = IPython.shadowns
400 # Object variable to store code object waiting execution. This is
400 # Object variable to store code object waiting execution. This is
401 # used mainly by the multithreaded shells, but it can come in handy in
401 # used mainly by the multithreaded shells, but it can come in handy in
402 # other situations. No need to use a Queue here, since it's a single
402 # other situations. No need to use a Queue here, since it's a single
403 # item which gets cleared once run.
403 # item which gets cleared once run.
404 self.code_to_run = None
404 self.code_to_run = None
405
405
406 # escapes for automatic behavior on the command line
406 # escapes for automatic behavior on the command line
407 self.ESC_SHELL = '!'
407 self.ESC_SHELL = '!'
408 self.ESC_SH_CAP = '!!'
408 self.ESC_SH_CAP = '!!'
409 self.ESC_HELP = '?'
409 self.ESC_HELP = '?'
410 self.ESC_MAGIC = '%'
410 self.ESC_MAGIC = '%'
411 self.ESC_QUOTE = ','
411 self.ESC_QUOTE = ','
412 self.ESC_QUOTE2 = ';'
412 self.ESC_QUOTE2 = ';'
413 self.ESC_PAREN = '/'
413 self.ESC_PAREN = '/'
414
414
415 # And their associated handlers
415 # And their associated handlers
416 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
416 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
417 self.ESC_QUOTE : self.handle_auto,
417 self.ESC_QUOTE : self.handle_auto,
418 self.ESC_QUOTE2 : self.handle_auto,
418 self.ESC_QUOTE2 : self.handle_auto,
419 self.ESC_MAGIC : self.handle_magic,
419 self.ESC_MAGIC : self.handle_magic,
420 self.ESC_HELP : self.handle_help,
420 self.ESC_HELP : self.handle_help,
421 self.ESC_SHELL : self.handle_shell_escape,
421 self.ESC_SHELL : self.handle_shell_escape,
422 self.ESC_SH_CAP : self.handle_shell_escape,
422 self.ESC_SH_CAP : self.handle_shell_escape,
423 }
423 }
424
424
425 # class initializations
425 # class initializations
426 Magic.__init__(self,self)
426 Magic.__init__(self,self)
427
427
428 # Python source parser/formatter for syntax highlighting
428 # Python source parser/formatter for syntax highlighting
429 pyformat = PyColorize.Parser().format
429 pyformat = PyColorize.Parser().format
430 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
430 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
431
431
432 # hooks holds pointers used for user-side customizations
432 # hooks holds pointers used for user-side customizations
433 self.hooks = Struct()
433 self.hooks = Struct()
434
434
435 self.strdispatchers = {}
435 self.strdispatchers = {}
436
436
437 # Set all default hooks, defined in the IPython.hooks module.
437 # Set all default hooks, defined in the IPython.hooks module.
438 hooks = IPython.hooks
438 hooks = IPython.hooks
439 for hook_name in hooks.__all__:
439 for hook_name in hooks.__all__:
440 # default hooks have priority 100, i.e. low; user hooks should have
440 # default hooks have priority 100, i.e. low; user hooks should have
441 # 0-100 priority
441 # 0-100 priority
442 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
442 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
443 #print "bound hook",hook_name
443 #print "bound hook",hook_name
444
444
445 # Flag to mark unconditional exit
445 # Flag to mark unconditional exit
446 self.exit_now = False
446 self.exit_now = False
447
447
448 self.usage_min = """\
448 self.usage_min = """\
449 An enhanced console for Python.
449 An enhanced console for Python.
450 Some of its features are:
450 Some of its features are:
451 - Readline support if the readline library is present.
451 - Readline support if the readline library is present.
452 - Tab completion in the local namespace.
452 - Tab completion in the local namespace.
453 - Logging of input, see command-line options.
453 - Logging of input, see command-line options.
454 - System shell escape via ! , eg !ls.
454 - System shell escape via ! , eg !ls.
455 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
455 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
456 - Keeps track of locally defined variables via %who, %whos.
456 - Keeps track of locally defined variables via %who, %whos.
457 - Show object information with a ? eg ?x or x? (use ?? for more info).
457 - Show object information with a ? eg ?x or x? (use ?? for more info).
458 """
458 """
459 if usage: self.usage = usage
459 if usage: self.usage = usage
460 else: self.usage = self.usage_min
460 else: self.usage = self.usage_min
461
461
462 # Storage
462 # Storage
463 self.rc = rc # This will hold all configuration information
463 self.rc = rc # This will hold all configuration information
464 self.pager = 'less'
464 self.pager = 'less'
465 # temporary files used for various purposes. Deleted at exit.
465 # temporary files used for various purposes. Deleted at exit.
466 self.tempfiles = []
466 self.tempfiles = []
467
467
468 # Keep track of readline usage (later set by init_readline)
468 # Keep track of readline usage (later set by init_readline)
469 self.has_readline = False
469 self.has_readline = False
470
470
471 # template for logfile headers. It gets resolved at runtime by the
471 # template for logfile headers. It gets resolved at runtime by the
472 # logstart method.
472 # logstart method.
473 self.loghead_tpl = \
473 self.loghead_tpl = \
474 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
474 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
475 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
475 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
476 #log# opts = %s
476 #log# opts = %s
477 #log# args = %s
477 #log# args = %s
478 #log# It is safe to make manual edits below here.
478 #log# It is safe to make manual edits below here.
479 #log#-----------------------------------------------------------------------
479 #log#-----------------------------------------------------------------------
480 """
480 """
481 # for pushd/popd management
481 # for pushd/popd management
482 try:
482 try:
483 self.home_dir = get_home_dir()
483 self.home_dir = get_home_dir()
484 except HomeDirError,msg:
484 except HomeDirError,msg:
485 fatal(msg)
485 fatal(msg)
486
486
487 self.dir_stack = []
487 self.dir_stack = []
488
488
489 # Functions to call the underlying shell.
489 # Functions to call the underlying shell.
490
490
491 # The first is similar to os.system, but it doesn't return a value,
491 # The first is similar to os.system, but it doesn't return a value,
492 # and it allows interpolation of variables in the user's namespace.
492 # and it allows interpolation of variables in the user's namespace.
493 self.system = lambda cmd: \
493 self.system = lambda cmd: \
494 shell(self.var_expand(cmd,depth=2),
494 shell(self.var_expand(cmd,depth=2),
495 header=self.rc.system_header,
495 header=self.rc.system_header,
496 verbose=self.rc.system_verbose)
496 verbose=self.rc.system_verbose)
497
497
498 # These are for getoutput and getoutputerror:
498 # These are for getoutput and getoutputerror:
499 self.getoutput = lambda cmd: \
499 self.getoutput = lambda cmd: \
500 getoutput(self.var_expand(cmd,depth=2),
500 getoutput(self.var_expand(cmd,depth=2),
501 header=self.rc.system_header,
501 header=self.rc.system_header,
502 verbose=self.rc.system_verbose)
502 verbose=self.rc.system_verbose)
503
503
504 self.getoutputerror = lambda cmd: \
504 self.getoutputerror = lambda cmd: \
505 getoutputerror(self.var_expand(cmd,depth=2),
505 getoutputerror(self.var_expand(cmd,depth=2),
506 header=self.rc.system_header,
506 header=self.rc.system_header,
507 verbose=self.rc.system_verbose)
507 verbose=self.rc.system_verbose)
508
508
509
509
510 # keep track of where we started running (mainly for crash post-mortem)
510 # keep track of where we started running (mainly for crash post-mortem)
511 self.starting_dir = os.getcwd()
511 self.starting_dir = os.getcwd()
512
512
513 # Various switches which can be set
513 # Various switches which can be set
514 self.CACHELENGTH = 5000 # this is cheap, it's just text
514 self.CACHELENGTH = 5000 # this is cheap, it's just text
515 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
515 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
516 self.banner2 = banner2
516 self.banner2 = banner2
517
517
518 # TraceBack handlers:
518 # TraceBack handlers:
519
519
520 # Syntax error handler.
520 # Syntax error handler.
521 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
521 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
522
522
523 # The interactive one is initialized with an offset, meaning we always
523 # The interactive one is initialized with an offset, meaning we always
524 # want to remove the topmost item in the traceback, which is our own
524 # want to remove the topmost item in the traceback, which is our own
525 # internal code. Valid modes: ['Plain','Context','Verbose']
525 # internal code. Valid modes: ['Plain','Context','Verbose']
526 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
526 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
527 color_scheme='NoColor',
527 color_scheme='NoColor',
528 tb_offset = 1)
528 tb_offset = 1)
529
529
530 # IPython itself shouldn't crash. This will produce a detailed
530 # IPython itself shouldn't crash. This will produce a detailed
531 # post-mortem if it does. But we only install the crash handler for
531 # post-mortem if it does. But we only install the crash handler for
532 # non-threaded shells, the threaded ones use a normal verbose reporter
532 # non-threaded shells, the threaded ones use a normal verbose reporter
533 # and lose the crash handler. This is because exceptions in the main
533 # and lose the crash handler. This is because exceptions in the main
534 # thread (such as in GUI code) propagate directly to sys.excepthook,
534 # thread (such as in GUI code) propagate directly to sys.excepthook,
535 # and there's no point in printing crash dumps for every user exception.
535 # and there's no point in printing crash dumps for every user exception.
536 if self.isthreaded:
536 if self.isthreaded:
537 ipCrashHandler = ultraTB.FormattedTB()
537 ipCrashHandler = ultraTB.FormattedTB()
538 else:
538 else:
539 from IPython import CrashHandler
539 from IPython import CrashHandler
540 ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
540 ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
541 self.set_crash_handler(ipCrashHandler)
541 self.set_crash_handler(ipCrashHandler)
542
542
543 # and add any custom exception handlers the user may have specified
543 # and add any custom exception handlers the user may have specified
544 self.set_custom_exc(*custom_exceptions)
544 self.set_custom_exc(*custom_exceptions)
545
545
546 # indentation management
546 # indentation management
547 self.autoindent = False
547 self.autoindent = False
548 self.indent_current_nsp = 0
548 self.indent_current_nsp = 0
549
549
550 # Make some aliases automatically
550 # Make some aliases automatically
551 # Prepare list of shell aliases to auto-define
551 # Prepare list of shell aliases to auto-define
552 if os.name == 'posix':
552 if os.name == 'posix':
553 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
553 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
554 'mv mv -i','rm rm -i','cp cp -i',
554 'mv mv -i','rm rm -i','cp cp -i',
555 'cat cat','less less','clear clear',
555 'cat cat','less less','clear clear',
556 # a better ls
556 # a better ls
557 'ls ls -F',
557 'ls ls -F',
558 # long ls
558 # long ls
559 'll ls -lF')
559 'll ls -lF')
560 # Extra ls aliases with color, which need special treatment on BSD
560 # Extra ls aliases with color, which need special treatment on BSD
561 # variants
561 # variants
562 ls_extra = ( # color ls
562 ls_extra = ( # color ls
563 'lc ls -F -o --color',
563 'lc ls -F -o --color',
564 # ls normal files only
564 # ls normal files only
565 'lf ls -F -o --color %l | grep ^-',
565 'lf ls -F -o --color %l | grep ^-',
566 # ls symbolic links
566 # ls symbolic links
567 'lk ls -F -o --color %l | grep ^l',
567 'lk ls -F -o --color %l | grep ^l',
568 # directories or links to directories,
568 # directories or links to directories,
569 'ldir ls -F -o --color %l | grep /$',
569 'ldir ls -F -o --color %l | grep /$',
570 # things which are executable
570 # things which are executable
571 'lx ls -F -o --color %l | grep ^-..x',
571 'lx ls -F -o --color %l | grep ^-..x',
572 )
572 )
573 # The BSDs don't ship GNU ls, so they don't understand the
573 # The BSDs don't ship GNU ls, so they don't understand the
574 # --color switch out of the box
574 # --color switch out of the box
575 if 'bsd' in sys.platform:
575 if 'bsd' in sys.platform:
576 ls_extra = ( # ls normal files only
576 ls_extra = ( # ls normal files only
577 'lf ls -lF | grep ^-',
577 'lf ls -lF | grep ^-',
578 # ls symbolic links
578 # ls symbolic links
579 'lk ls -lF | grep ^l',
579 'lk ls -lF | grep ^l',
580 # directories or links to directories,
580 # directories or links to directories,
581 'ldir ls -lF | grep /$',
581 'ldir ls -lF | grep /$',
582 # things which are executable
582 # things which are executable
583 'lx ls -lF | grep ^-..x',
583 'lx ls -lF | grep ^-..x',
584 )
584 )
585 auto_alias = auto_alias + ls_extra
585 auto_alias = auto_alias + ls_extra
586 elif os.name in ['nt','dos']:
586 elif os.name in ['nt','dos']:
587 auto_alias = ('ls dir /on',
587 auto_alias = ('ls dir /on',
588 'ddir dir /ad /on', 'ldir dir /ad /on',
588 'ddir dir /ad /on', 'ldir dir /ad /on',
589 'mkdir mkdir','rmdir rmdir','echo echo',
589 'mkdir mkdir','rmdir rmdir','echo echo',
590 'ren ren','cls cls','copy copy')
590 'ren ren','cls cls','copy copy')
591 else:
591 else:
592 auto_alias = ()
592 auto_alias = ()
593 self.auto_alias = [s.split(None,1) for s in auto_alias]
593 self.auto_alias = [s.split(None,1) for s in auto_alias]
594
594
595 # Produce a public API instance
595 # Produce a public API instance
596 self.api = IPython.ipapi.IPApi(self)
596 self.api = IPython.ipapi.IPApi(self)
597
597
598 # Call the actual (public) initializer
598 # Call the actual (public) initializer
599 self.init_auto_alias()
599 self.init_auto_alias()
600
600
601 # track which builtins we add, so we can clean up later
601 # track which builtins we add, so we can clean up later
602 self.builtins_added = {}
602 self.builtins_added = {}
603 # This method will add the necessary builtins for operation, but
603 # This method will add the necessary builtins for operation, but
604 # tracking what it did via the builtins_added dict.
604 # tracking what it did via the builtins_added dict.
605 self.add_builtins()
605 self.add_builtins()
606
606
607
607
608
608
609 # end __init__
609 # end __init__
610
610
611 def var_expand(self,cmd,depth=0):
611 def var_expand(self,cmd,depth=0):
612 """Expand python variables in a string.
612 """Expand python variables in a string.
613
613
614 The depth argument indicates how many frames above the caller should
614 The depth argument indicates how many frames above the caller should
615 be walked to look for the local namespace where to expand variables.
615 be walked to look for the local namespace where to expand variables.
616
616
617 The global namespace for expansion is always the user's interactive
617 The global namespace for expansion is always the user's interactive
618 namespace.
618 namespace.
619 """
619 """
620
620
621 return str(ItplNS(cmd,
621 return str(ItplNS(cmd,
622 self.user_ns, # globals
622 self.user_ns, # globals
623 # Skip our own frame in searching for locals:
623 # Skip our own frame in searching for locals:
624 sys._getframe(depth+1).f_locals # locals
624 sys._getframe(depth+1).f_locals # locals
625 ))
625 ))
626
626
627 def pre_config_initialization(self):
627 def pre_config_initialization(self):
628 """Pre-configuration init method
628 """Pre-configuration init method
629
629
630 This is called before the configuration files are processed to
630 This is called before the configuration files are processed to
631 prepare the services the config files might need.
631 prepare the services the config files might need.
632
632
633 self.rc already has reasonable default values at this point.
633 self.rc already has reasonable default values at this point.
634 """
634 """
635 rc = self.rc
635 rc = self.rc
636 try:
636 try:
637 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
637 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
638 except exceptions.UnicodeDecodeError:
638 except exceptions.UnicodeDecodeError:
639 print "Your ipythondir can't be decoded to unicode!"
639 print "Your ipythondir can't be decoded to unicode!"
640 print "Please set HOME environment variable to something that"
640 print "Please set HOME environment variable to something that"
641 print r"only has ASCII characters, e.g. c:\home"
641 print r"only has ASCII characters, e.g. c:\home"
642 print "Now it is",rc.ipythondir
642 print "Now it is",rc.ipythondir
643 sys.exit()
643 sys.exit()
644 self.shadowhist = IPython.history.ShadowHist(self.db)
644 self.shadowhist = IPython.history.ShadowHist(self.db)
645
645
646
646
647 def post_config_initialization(self):
647 def post_config_initialization(self):
648 """Post configuration init method
648 """Post configuration init method
649
649
650 This is called after the configuration files have been processed to
650 This is called after the configuration files have been processed to
651 'finalize' the initialization."""
651 'finalize' the initialization."""
652
652
653 rc = self.rc
653 rc = self.rc
654
654
655 # Object inspector
655 # Object inspector
656 self.inspector = OInspect.Inspector(OInspect.InspectColors,
656 self.inspector = OInspect.Inspector(OInspect.InspectColors,
657 PyColorize.ANSICodeColors,
657 PyColorize.ANSICodeColors,
658 'NoColor',
658 'NoColor',
659 rc.object_info_string_level)
659 rc.object_info_string_level)
660
660
661 self.rl_next_input = None
661 self.rl_next_input = None
662 self.rl_do_indent = False
662 self.rl_do_indent = False
663 # Load readline proper
663 # Load readline proper
664 if rc.readline:
664 if rc.readline:
665 self.init_readline()
665 self.init_readline()
666
666
667
667
668 # local shortcut, this is used a LOT
668 # local shortcut, this is used a LOT
669 self.log = self.logger.log
669 self.log = self.logger.log
670
670
671 # Initialize cache, set in/out prompts and printing system
671 # Initialize cache, set in/out prompts and printing system
672 self.outputcache = CachedOutput(self,
672 self.outputcache = CachedOutput(self,
673 rc.cache_size,
673 rc.cache_size,
674 rc.pprint,
674 rc.pprint,
675 input_sep = rc.separate_in,
675 input_sep = rc.separate_in,
676 output_sep = rc.separate_out,
676 output_sep = rc.separate_out,
677 output_sep2 = rc.separate_out2,
677 output_sep2 = rc.separate_out2,
678 ps1 = rc.prompt_in1,
678 ps1 = rc.prompt_in1,
679 ps2 = rc.prompt_in2,
679 ps2 = rc.prompt_in2,
680 ps_out = rc.prompt_out,
680 ps_out = rc.prompt_out,
681 pad_left = rc.prompts_pad_left)
681 pad_left = rc.prompts_pad_left)
682
682
683 # user may have over-ridden the default print hook:
683 # user may have over-ridden the default print hook:
684 try:
684 try:
685 self.outputcache.__class__.display = self.hooks.display
685 self.outputcache.__class__.display = self.hooks.display
686 except AttributeError:
686 except AttributeError:
687 pass
687 pass
688
688
689 # I don't like assigning globally to sys, because it means when
689 # I don't like assigning globally to sys, because it means when
690 # embedding instances, each embedded instance overrides the previous
690 # embedding instances, each embedded instance overrides the previous
691 # choice. But sys.displayhook seems to be called internally by exec,
691 # choice. But sys.displayhook seems to be called internally by exec,
692 # so I don't see a way around it. We first save the original and then
692 # so I don't see a way around it. We first save the original and then
693 # overwrite it.
693 # overwrite it.
694 self.sys_displayhook = sys.displayhook
694 self.sys_displayhook = sys.displayhook
695 sys.displayhook = self.outputcache
695 sys.displayhook = self.outputcache
696
696
697 # Do a proper resetting of doctest, including the necessary displayhook
697 # Do a proper resetting of doctest, including the necessary displayhook
698 # monkeypatching
698 # monkeypatching
699 doctest_reload()
699 doctest_reload()
700
700
701 # Set user colors (don't do it in the constructor above so that it
701 # Set user colors (don't do it in the constructor above so that it
702 # doesn't crash if colors option is invalid)
702 # doesn't crash if colors option is invalid)
703 self.magic_colors(rc.colors)
703 self.magic_colors(rc.colors)
704
704
705 # Set calling of pdb on exceptions
705 # Set calling of pdb on exceptions
706 self.call_pdb = rc.pdb
706 self.call_pdb = rc.pdb
707
707
708 # Load user aliases
708 # Load user aliases
709 for alias in rc.alias:
709 for alias in rc.alias:
710 self.magic_alias(alias)
710 self.magic_alias(alias)
711
711
712 self.hooks.late_startup_hook()
712 self.hooks.late_startup_hook()
713
713
714 batchrun = False
714 batchrun = False
715 for batchfile in [path(arg) for arg in self.rc.args
715 for batchfile in [path(arg) for arg in self.rc.args
716 if arg.lower().endswith('.ipy')]:
716 if arg.lower().endswith('.ipy')]:
717 if not batchfile.isfile():
717 if not batchfile.isfile():
718 print "No such batch file:", batchfile
718 print "No such batch file:", batchfile
719 continue
719 continue
720 self.api.runlines(batchfile.text())
720 self.api.runlines(batchfile.text())
721 batchrun = True
721 batchrun = True
722 # without -i option, exit after running the batch file
722 # without -i option, exit after running the batch file
723 if batchrun and not self.rc.interact:
723 if batchrun and not self.rc.interact:
724 self.exit_now = True
724 self.exit_now = True
725
725
726 def add_builtins(self):
726 def add_builtins(self):
727 """Store ipython references into the builtin namespace.
727 """Store ipython references into the builtin namespace.
728
728
729 Some parts of ipython operate via builtins injected here, which hold a
729 Some parts of ipython operate via builtins injected here, which hold a
730 reference to IPython itself."""
730 reference to IPython itself."""
731
731
732 # TODO: deprecate all except _ip; 'jobs' should be installed
732 # TODO: deprecate all except _ip; 'jobs' should be installed
733 # by an extension and the rest are under _ip, ipalias is redundant
733 # by an extension and the rest are under _ip, ipalias is redundant
734 builtins_new = dict(__IPYTHON__ = self,
734 builtins_new = dict(__IPYTHON__ = self,
735 ip_set_hook = self.set_hook,
735 ip_set_hook = self.set_hook,
736 jobs = self.jobs,
736 jobs = self.jobs,
737 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),
737 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),
738 ipalias = wrap_deprecated(self.ipalias),
738 ipalias = wrap_deprecated(self.ipalias),
739 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
739 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
740 _ip = self.api
740 _ip = self.api
741 )
741 )
742 for biname,bival in builtins_new.items():
742 for biname,bival in builtins_new.items():
743 try:
743 try:
744 # store the orignal value so we can restore it
744 # store the orignal value so we can restore it
745 self.builtins_added[biname] = __builtin__.__dict__[biname]
745 self.builtins_added[biname] = __builtin__.__dict__[biname]
746 except KeyError:
746 except KeyError:
747 # or mark that it wasn't defined, and we'll just delete it at
747 # or mark that it wasn't defined, and we'll just delete it at
748 # cleanup
748 # cleanup
749 self.builtins_added[biname] = Undefined
749 self.builtins_added[biname] = Undefined
750 __builtin__.__dict__[biname] = bival
750 __builtin__.__dict__[biname] = bival
751
751
752 # Keep in the builtins a flag for when IPython is active. We set it
752 # Keep in the builtins a flag for when IPython is active. We set it
753 # with setdefault so that multiple nested IPythons don't clobber one
753 # with setdefault so that multiple nested IPythons don't clobber one
754 # another. Each will increase its value by one upon being activated,
754 # another. Each will increase its value by one upon being activated,
755 # which also gives us a way to determine the nesting level.
755 # which also gives us a way to determine the nesting level.
756 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
756 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
757
757
758 def clean_builtins(self):
758 def clean_builtins(self):
759 """Remove any builtins which might have been added by add_builtins, or
759 """Remove any builtins which might have been added by add_builtins, or
760 restore overwritten ones to their previous values."""
760 restore overwritten ones to their previous values."""
761 for biname,bival in self.builtins_added.items():
761 for biname,bival in self.builtins_added.items():
762 if bival is Undefined:
762 if bival is Undefined:
763 del __builtin__.__dict__[biname]
763 del __builtin__.__dict__[biname]
764 else:
764 else:
765 __builtin__.__dict__[biname] = bival
765 __builtin__.__dict__[biname] = bival
766 self.builtins_added.clear()
766 self.builtins_added.clear()
767
767
768 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
768 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
769 """set_hook(name,hook) -> sets an internal IPython hook.
769 """set_hook(name,hook) -> sets an internal IPython hook.
770
770
771 IPython exposes some of its internal API as user-modifiable hooks. By
771 IPython exposes some of its internal API as user-modifiable hooks. By
772 adding your function to one of these hooks, you can modify IPython's
772 adding your function to one of these hooks, you can modify IPython's
773 behavior to call at runtime your own routines."""
773 behavior to call at runtime your own routines."""
774
774
775 # At some point in the future, this should validate the hook before it
775 # At some point in the future, this should validate the hook before it
776 # accepts it. Probably at least check that the hook takes the number
776 # accepts it. Probably at least check that the hook takes the number
777 # of args it's supposed to.
777 # of args it's supposed to.
778
778
779 f = new.instancemethod(hook,self,self.__class__)
779 f = new.instancemethod(hook,self,self.__class__)
780
780
781 # check if the hook is for strdispatcher first
781 # check if the hook is for strdispatcher first
782 if str_key is not None:
782 if str_key is not None:
783 sdp = self.strdispatchers.get(name, StrDispatch())
783 sdp = self.strdispatchers.get(name, StrDispatch())
784 sdp.add_s(str_key, f, priority )
784 sdp.add_s(str_key, f, priority )
785 self.strdispatchers[name] = sdp
785 self.strdispatchers[name] = sdp
786 return
786 return
787 if re_key is not None:
787 if re_key is not None:
788 sdp = self.strdispatchers.get(name, StrDispatch())
788 sdp = self.strdispatchers.get(name, StrDispatch())
789 sdp.add_re(re.compile(re_key), f, priority )
789 sdp.add_re(re.compile(re_key), f, priority )
790 self.strdispatchers[name] = sdp
790 self.strdispatchers[name] = sdp
791 return
791 return
792
792
793 dp = getattr(self.hooks, name, None)
793 dp = getattr(self.hooks, name, None)
794 if name not in IPython.hooks.__all__:
794 if name not in IPython.hooks.__all__:
795 print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
795 print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
796 if not dp:
796 if not dp:
797 dp = IPython.hooks.CommandChainDispatcher()
797 dp = IPython.hooks.CommandChainDispatcher()
798
798
799 try:
799 try:
800 dp.add(f,priority)
800 dp.add(f,priority)
801 except AttributeError:
801 except AttributeError:
802 # it was not commandchain, plain old func - replace
802 # it was not commandchain, plain old func - replace
803 dp = f
803 dp = f
804
804
805 setattr(self.hooks,name, dp)
805 setattr(self.hooks,name, dp)
806
806
807
807
808 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
808 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
809
809
810 def set_crash_handler(self,crashHandler):
810 def set_crash_handler(self,crashHandler):
811 """Set the IPython crash handler.
811 """Set the IPython crash handler.
812
812
813 This must be a callable with a signature suitable for use as
813 This must be a callable with a signature suitable for use as
814 sys.excepthook."""
814 sys.excepthook."""
815
815
816 # Install the given crash handler as the Python exception hook
816 # Install the given crash handler as the Python exception hook
817 sys.excepthook = crashHandler
817 sys.excepthook = crashHandler
818
818
819 # The instance will store a pointer to this, so that runtime code
819 # The instance will store a pointer to this, so that runtime code
820 # (such as magics) can access it. This is because during the
820 # (such as magics) can access it. This is because during the
821 # read-eval loop, it gets temporarily overwritten (to deal with GUI
821 # read-eval loop, it gets temporarily overwritten (to deal with GUI
822 # frameworks).
822 # frameworks).
823 self.sys_excepthook = sys.excepthook
823 self.sys_excepthook = sys.excepthook
824
824
825
825
826 def set_custom_exc(self,exc_tuple,handler):
826 def set_custom_exc(self,exc_tuple,handler):
827 """set_custom_exc(exc_tuple,handler)
827 """set_custom_exc(exc_tuple,handler)
828
828
829 Set a custom exception handler, which will be called if any of the
829 Set a custom exception handler, which will be called if any of the
830 exceptions in exc_tuple occur in the mainloop (specifically, in the
830 exceptions in exc_tuple occur in the mainloop (specifically, in the
831 runcode() method.
831 runcode() method.
832
832
833 Inputs:
833 Inputs:
834
834
835 - exc_tuple: a *tuple* of valid exceptions to call the defined
835 - exc_tuple: a *tuple* of valid exceptions to call the defined
836 handler for. It is very important that you use a tuple, and NOT A
836 handler for. It is very important that you use a tuple, and NOT A
837 LIST here, because of the way Python's except statement works. If
837 LIST here, because of the way Python's except statement works. If
838 you only want to trap a single exception, use a singleton tuple:
838 you only want to trap a single exception, use a singleton tuple:
839
839
840 exc_tuple == (MyCustomException,)
840 exc_tuple == (MyCustomException,)
841
841
842 - handler: this must be defined as a function with the following
842 - handler: this must be defined as a function with the following
843 basic interface: def my_handler(self,etype,value,tb).
843 basic interface: def my_handler(self,etype,value,tb).
844
844
845 This will be made into an instance method (via new.instancemethod)
845 This will be made into an instance method (via new.instancemethod)
846 of IPython itself, and it will be called if any of the exceptions
846 of IPython itself, and it will be called if any of the exceptions
847 listed in the exc_tuple are caught. If the handler is None, an
847 listed in the exc_tuple are caught. If the handler is None, an
848 internal basic one is used, which just prints basic info.
848 internal basic one is used, which just prints basic info.
849
849
850 WARNING: by putting in your own exception handler into IPython's main
850 WARNING: by putting in your own exception handler into IPython's main
851 execution loop, you run a very good chance of nasty crashes. This
851 execution loop, you run a very good chance of nasty crashes. This
852 facility should only be used if you really know what you are doing."""
852 facility should only be used if you really know what you are doing."""
853
853
854 assert type(exc_tuple)==type(()) , \
854 assert type(exc_tuple)==type(()) , \
855 "The custom exceptions must be given AS A TUPLE."
855 "The custom exceptions must be given AS A TUPLE."
856
856
857 def dummy_handler(self,etype,value,tb):
857 def dummy_handler(self,etype,value,tb):
858 print '*** Simple custom exception handler ***'
858 print '*** Simple custom exception handler ***'
859 print 'Exception type :',etype
859 print 'Exception type :',etype
860 print 'Exception value:',value
860 print 'Exception value:',value
861 print 'Traceback :',tb
861 print 'Traceback :',tb
862 print 'Source code :','\n'.join(self.buffer)
862 print 'Source code :','\n'.join(self.buffer)
863
863
864 if handler is None: handler = dummy_handler
864 if handler is None: handler = dummy_handler
865
865
866 self.CustomTB = new.instancemethod(handler,self,self.__class__)
866 self.CustomTB = new.instancemethod(handler,self,self.__class__)
867 self.custom_exceptions = exc_tuple
867 self.custom_exceptions = exc_tuple
868
868
869 def set_custom_completer(self,completer,pos=0):
869 def set_custom_completer(self,completer,pos=0):
870 """set_custom_completer(completer,pos=0)
870 """set_custom_completer(completer,pos=0)
871
871
872 Adds a new custom completer function.
872 Adds a new custom completer function.
873
873
874 The position argument (defaults to 0) is the index in the completers
874 The position argument (defaults to 0) is the index in the completers
875 list where you want the completer to be inserted."""
875 list where you want the completer to be inserted."""
876
876
877 newcomp = new.instancemethod(completer,self.Completer,
877 newcomp = new.instancemethod(completer,self.Completer,
878 self.Completer.__class__)
878 self.Completer.__class__)
879 self.Completer.matchers.insert(pos,newcomp)
879 self.Completer.matchers.insert(pos,newcomp)
880
880
881 def set_completer(self):
881 def set_completer(self):
882 """reset readline's completer to be our own."""
882 """reset readline's completer to be our own."""
883 self.readline.set_completer(self.Completer.complete)
883 self.readline.set_completer(self.Completer.complete)
884
884
885 def _get_call_pdb(self):
885 def _get_call_pdb(self):
886 return self._call_pdb
886 return self._call_pdb
887
887
888 def _set_call_pdb(self,val):
888 def _set_call_pdb(self,val):
889
889
890 if val not in (0,1,False,True):
890 if val not in (0,1,False,True):
891 raise ValueError,'new call_pdb value must be boolean'
891 raise ValueError,'new call_pdb value must be boolean'
892
892
893 # store value in instance
893 # store value in instance
894 self._call_pdb = val
894 self._call_pdb = val
895
895
896 # notify the actual exception handlers
896 # notify the actual exception handlers
897 self.InteractiveTB.call_pdb = val
897 self.InteractiveTB.call_pdb = val
898 if self.isthreaded:
898 if self.isthreaded:
899 try:
899 try:
900 self.sys_excepthook.call_pdb = val
900 self.sys_excepthook.call_pdb = val
901 except:
901 except:
902 warn('Failed to activate pdb for threaded exception handler')
902 warn('Failed to activate pdb for threaded exception handler')
903
903
904 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
904 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
905 'Control auto-activation of pdb at exceptions')
905 'Control auto-activation of pdb at exceptions')
906
906
907
907
908 # These special functions get installed in the builtin namespace, to
908 # These special functions get installed in the builtin namespace, to
909 # provide programmatic (pure python) access to magics, aliases and system
909 # provide programmatic (pure python) access to magics, aliases and system
910 # calls. This is important for logging, user scripting, and more.
910 # calls. This is important for logging, user scripting, and more.
911
911
912 # We are basically exposing, via normal python functions, the three
912 # We are basically exposing, via normal python functions, the three
913 # mechanisms in which ipython offers special call modes (magics for
913 # mechanisms in which ipython offers special call modes (magics for
914 # internal control, aliases for direct system access via pre-selected
914 # internal control, aliases for direct system access via pre-selected
915 # names, and !cmd for calling arbitrary system commands).
915 # names, and !cmd for calling arbitrary system commands).
916
916
917 def ipmagic(self,arg_s):
917 def ipmagic(self,arg_s):
918 """Call a magic function by name.
918 """Call a magic function by name.
919
919
920 Input: a string containing the name of the magic function to call and any
920 Input: a string containing the name of the magic function to call and any
921 additional arguments to be passed to the magic.
921 additional arguments to be passed to the magic.
922
922
923 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
923 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
924 prompt:
924 prompt:
925
925
926 In[1]: %name -opt foo bar
926 In[1]: %name -opt foo bar
927
927
928 To call a magic without arguments, simply use ipmagic('name').
928 To call a magic without arguments, simply use ipmagic('name').
929
929
930 This provides a proper Python function to call IPython's magics in any
930 This provides a proper Python function to call IPython's magics in any
931 valid Python code you can type at the interpreter, including loops and
931 valid Python code you can type at the interpreter, including loops and
932 compound statements. It is added by IPython to the Python builtin
932 compound statements. It is added by IPython to the Python builtin
933 namespace upon initialization."""
933 namespace upon initialization."""
934
934
935 args = arg_s.split(' ',1)
935 args = arg_s.split(' ',1)
936 magic_name = args[0]
936 magic_name = args[0]
937 magic_name = magic_name.lstrip(self.ESC_MAGIC)
937 magic_name = magic_name.lstrip(self.ESC_MAGIC)
938
938
939 try:
939 try:
940 magic_args = args[1]
940 magic_args = args[1]
941 except IndexError:
941 except IndexError:
942 magic_args = ''
942 magic_args = ''
943 fn = getattr(self,'magic_'+magic_name,None)
943 fn = getattr(self,'magic_'+magic_name,None)
944 if fn is None:
944 if fn is None:
945 error("Magic function `%s` not found." % magic_name)
945 error("Magic function `%s` not found." % magic_name)
946 else:
946 else:
947 magic_args = self.var_expand(magic_args,1)
947 magic_args = self.var_expand(magic_args,1)
948 return fn(magic_args)
948 return fn(magic_args)
949
949
950 def ipalias(self,arg_s):
950 def ipalias(self,arg_s):
951 """Call an alias by name.
951 """Call an alias by name.
952
952
953 Input: a string containing the name of the alias to call and any
953 Input: a string containing the name of the alias to call and any
954 additional arguments to be passed to the magic.
954 additional arguments to be passed to the magic.
955
955
956 ipalias('name -opt foo bar') is equivalent to typing at the ipython
956 ipalias('name -opt foo bar') is equivalent to typing at the ipython
957 prompt:
957 prompt:
958
958
959 In[1]: name -opt foo bar
959 In[1]: name -opt foo bar
960
960
961 To call an alias without arguments, simply use ipalias('name').
961 To call an alias without arguments, simply use ipalias('name').
962
962
963 This provides a proper Python function to call IPython's aliases in any
963 This provides a proper Python function to call IPython's aliases in any
964 valid Python code you can type at the interpreter, including loops and
964 valid Python code you can type at the interpreter, including loops and
965 compound statements. It is added by IPython to the Python builtin
965 compound statements. It is added by IPython to the Python builtin
966 namespace upon initialization."""
966 namespace upon initialization."""
967
967
968 args = arg_s.split(' ',1)
968 args = arg_s.split(' ',1)
969 alias_name = args[0]
969 alias_name = args[0]
970 try:
970 try:
971 alias_args = args[1]
971 alias_args = args[1]
972 except IndexError:
972 except IndexError:
973 alias_args = ''
973 alias_args = ''
974 if alias_name in self.alias_table:
974 if alias_name in self.alias_table:
975 self.call_alias(alias_name,alias_args)
975 self.call_alias(alias_name,alias_args)
976 else:
976 else:
977 error("Alias `%s` not found." % alias_name)
977 error("Alias `%s` not found." % alias_name)
978
978
979 def ipsystem(self,arg_s):
979 def ipsystem(self,arg_s):
980 """Make a system call, using IPython."""
980 """Make a system call, using IPython."""
981
981
982 self.system(arg_s)
982 self.system(arg_s)
983
983
984 def complete(self,text):
984 def complete(self,text):
985 """Return a sorted list of all possible completions on text.
985 """Return a sorted list of all possible completions on text.
986
986
987 Inputs:
987 Inputs:
988
988
989 - text: a string of text to be completed on.
989 - text: a string of text to be completed on.
990
990
991 This is a wrapper around the completion mechanism, similar to what
991 This is a wrapper around the completion mechanism, similar to what
992 readline does at the command line when the TAB key is hit. By
992 readline does at the command line when the TAB key is hit. By
993 exposing it as a method, it can be used by other non-readline
993 exposing it as a method, it can be used by other non-readline
994 environments (such as GUIs) for text completion.
994 environments (such as GUIs) for text completion.
995
995
996 Simple usage example:
996 Simple usage example:
997
997
998 In [1]: x = 'hello'
998 In [1]: x = 'hello'
999
999
1000 In [2]: __IP.complete('x.l')
1000 In [2]: __IP.complete('x.l')
1001 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
1001 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
1002
1002
1003 complete = self.Completer.complete
1003 complete = self.Completer.complete
1004 state = 0
1004 state = 0
1005 # use a dict so we get unique keys, since ipyhton's multiple
1005 # use a dict so we get unique keys, since ipyhton's multiple
1006 # completers can return duplicates. When we make 2.4 a requirement,
1006 # completers can return duplicates. When we make 2.4 a requirement,
1007 # start using sets instead, which are faster.
1007 # start using sets instead, which are faster.
1008 comps = {}
1008 comps = {}
1009 while True:
1009 while True:
1010 newcomp = complete(text,state,line_buffer=text)
1010 newcomp = complete(text,state,line_buffer=text)
1011 if newcomp is None:
1011 if newcomp is None:
1012 break
1012 break
1013 comps[newcomp] = 1
1013 comps[newcomp] = 1
1014 state += 1
1014 state += 1
1015 outcomps = comps.keys()
1015 outcomps = comps.keys()
1016 outcomps.sort()
1016 outcomps.sort()
1017 return outcomps
1017 return outcomps
1018
1018
1019 def set_completer_frame(self, frame=None):
1019 def set_completer_frame(self, frame=None):
1020 if frame:
1020 if frame:
1021 self.Completer.namespace = frame.f_locals
1021 self.Completer.namespace = frame.f_locals
1022 self.Completer.global_namespace = frame.f_globals
1022 self.Completer.global_namespace = frame.f_globals
1023 else:
1023 else:
1024 self.Completer.namespace = self.user_ns
1024 self.Completer.namespace = self.user_ns
1025 self.Completer.global_namespace = self.user_global_ns
1025 self.Completer.global_namespace = self.user_global_ns
1026
1026
1027 def init_auto_alias(self):
1027 def init_auto_alias(self):
1028 """Define some aliases automatically.
1028 """Define some aliases automatically.
1029
1029
1030 These are ALL parameter-less aliases"""
1030 These are ALL parameter-less aliases"""
1031
1031
1032 for alias,cmd in self.auto_alias:
1032 for alias,cmd in self.auto_alias:
1033 self.getapi().defalias(alias,cmd)
1033 self.getapi().defalias(alias,cmd)
1034
1034
1035
1035
1036 def alias_table_validate(self,verbose=0):
1036 def alias_table_validate(self,verbose=0):
1037 """Update information about the alias table.
1037 """Update information about the alias table.
1038
1038
1039 In particular, make sure no Python keywords/builtins are in it."""
1039 In particular, make sure no Python keywords/builtins are in it."""
1040
1040
1041 no_alias = self.no_alias
1041 no_alias = self.no_alias
1042 for k in self.alias_table.keys():
1042 for k in self.alias_table.keys():
1043 if k in no_alias:
1043 if k in no_alias:
1044 del self.alias_table[k]
1044 del self.alias_table[k]
1045 if verbose:
1045 if verbose:
1046 print ("Deleting alias <%s>, it's a Python "
1046 print ("Deleting alias <%s>, it's a Python "
1047 "keyword or builtin." % k)
1047 "keyword or builtin." % k)
1048
1048
1049 def set_autoindent(self,value=None):
1049 def set_autoindent(self,value=None):
1050 """Set the autoindent flag, checking for readline support.
1050 """Set the autoindent flag, checking for readline support.
1051
1051
1052 If called with no arguments, it acts as a toggle."""
1052 If called with no arguments, it acts as a toggle."""
1053
1053
1054 if not self.has_readline:
1054 if not self.has_readline:
1055 if os.name == 'posix':
1055 if os.name == 'posix':
1056 warn("The auto-indent feature requires the readline library")
1056 warn("The auto-indent feature requires the readline library")
1057 self.autoindent = 0
1057 self.autoindent = 0
1058 return
1058 return
1059 if value is None:
1059 if value is None:
1060 self.autoindent = not self.autoindent
1060 self.autoindent = not self.autoindent
1061 else:
1061 else:
1062 self.autoindent = value
1062 self.autoindent = value
1063
1063
1064 def rc_set_toggle(self,rc_field,value=None):
1064 def rc_set_toggle(self,rc_field,value=None):
1065 """Set or toggle a field in IPython's rc config. structure.
1065 """Set or toggle a field in IPython's rc config. structure.
1066
1066
1067 If called with no arguments, it acts as a toggle.
1067 If called with no arguments, it acts as a toggle.
1068
1068
1069 If called with a non-existent field, the resulting AttributeError
1069 If called with a non-existent field, the resulting AttributeError
1070 exception will propagate out."""
1070 exception will propagate out."""
1071
1071
1072 rc_val = getattr(self.rc,rc_field)
1072 rc_val = getattr(self.rc,rc_field)
1073 if value is None:
1073 if value is None:
1074 value = not rc_val
1074 value = not rc_val
1075 setattr(self.rc,rc_field,value)
1075 setattr(self.rc,rc_field,value)
1076
1076
1077 def user_setup(self,ipythondir,rc_suffix,mode='install'):
1077 def user_setup(self,ipythondir,rc_suffix,mode='install'):
1078 """Install the user configuration directory.
1078 """Install the user configuration directory.
1079
1079
1080 Can be called when running for the first time or to upgrade the user's
1080 Can be called when running for the first time or to upgrade the user's
1081 .ipython/ directory with the mode parameter. Valid modes are 'install'
1081 .ipython/ directory with the mode parameter. Valid modes are 'install'
1082 and 'upgrade'."""
1082 and 'upgrade'."""
1083
1083
1084 def wait():
1084 def wait():
1085 try:
1085 try:
1086 raw_input("Please press <RETURN> to start IPython.")
1086 raw_input("Please press <RETURN> to start IPython.")
1087 except EOFError:
1087 except EOFError:
1088 print >> Term.cout
1088 print >> Term.cout
1089 print '*'*70
1089 print '*'*70
1090
1090
1091 cwd = os.getcwd() # remember where we started
1091 cwd = os.getcwd() # remember where we started
1092 glb = glob.glob
1092 glb = glob.glob
1093 print '*'*70
1093 print '*'*70
1094 if mode == 'install':
1094 if mode == 'install':
1095 print \
1095 print \
1096 """Welcome to IPython. I will try to create a personal configuration directory
1096 """Welcome to IPython. I will try to create a personal configuration directory
1097 where you can customize many aspects of IPython's functionality in:\n"""
1097 where you can customize many aspects of IPython's functionality in:\n"""
1098 else:
1098 else:
1099 print 'I am going to upgrade your configuration in:'
1099 print 'I am going to upgrade your configuration in:'
1100
1100
1101 print ipythondir
1101 print ipythondir
1102
1102
1103 rcdirend = os.path.join('IPython','UserConfig')
1103 rcdirend = os.path.join('IPython','UserConfig')
1104 cfg = lambda d: os.path.join(d,rcdirend)
1104 cfg = lambda d: os.path.join(d,rcdirend)
1105 try:
1105 try:
1106 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
1106 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
1107 print "Initializing from configuration",rcdir
1107 print "Initializing from configuration",rcdir
1108 except IndexError:
1108 except IndexError:
1109 warning = """
1109 warning = """
1110 Installation error. IPython's directory was not found.
1110 Installation error. IPython's directory was not found.
1111
1111
1112 Check the following:
1112 Check the following:
1113
1113
1114 The ipython/IPython directory should be in a directory belonging to your
1114 The ipython/IPython directory should be in a directory belonging to your
1115 PYTHONPATH environment variable (that is, it should be in a directory
1115 PYTHONPATH environment variable (that is, it should be in a directory
1116 belonging to sys.path). You can copy it explicitly there or just link to it.
1116 belonging to sys.path). You can copy it explicitly there or just link to it.
1117
1117
1118 IPython will create a minimal default configuration for you.
1118 IPython will create a minimal default configuration for you.
1119
1119
1120 """
1120 """
1121 warn(warning)
1121 warn(warning)
1122 wait()
1122 wait()
1123
1123
1124 if sys.platform =='win32':
1124 if sys.platform =='win32':
1125 inif = 'ipythonrc.ini'
1125 inif = 'ipythonrc.ini'
1126 else:
1126 else:
1127 inif = 'ipythonrc'
1127 inif = 'ipythonrc'
1128 minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }
1128 minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }
1129 os.makedirs(ipythondir)
1129 os.makedirs(ipythondir)
1130 for f, cont in minimal_setup.items():
1130 for f, cont in minimal_setup.items():
1131 open(ipythondir + '/' + f,'w').write(cont)
1131 open(ipythondir + '/' + f,'w').write(cont)
1132
1132
1133 return
1133 return
1134
1134
1135 if mode == 'install':
1135 if mode == 'install':
1136 try:
1136 try:
1137 shutil.copytree(rcdir,ipythondir)
1137 shutil.copytree(rcdir,ipythondir)
1138 os.chdir(ipythondir)
1138 os.chdir(ipythondir)
1139 rc_files = glb("ipythonrc*")
1139 rc_files = glb("ipythonrc*")
1140 for rc_file in rc_files:
1140 for rc_file in rc_files:
1141 os.rename(rc_file,rc_file+rc_suffix)
1141 os.rename(rc_file,rc_file+rc_suffix)
1142 except:
1142 except:
1143 warning = """
1143 warning = """
1144
1144
1145 There was a problem with the installation:
1145 There was a problem with the installation:
1146 %s
1146 %s
1147 Try to correct it or contact the developers if you think it's a bug.
1147 Try to correct it or contact the developers if you think it's a bug.
1148 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
1148 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
1149 warn(warning)
1149 warn(warning)
1150 wait()
1150 wait()
1151 return
1151 return
1152
1152
1153 elif mode == 'upgrade':
1153 elif mode == 'upgrade':
1154 try:
1154 try:
1155 os.chdir(ipythondir)
1155 os.chdir(ipythondir)
1156 except:
1156 except:
1157 print """
1157 print """
1158 Can not upgrade: changing to directory %s failed. Details:
1158 Can not upgrade: changing to directory %s failed. Details:
1159 %s
1159 %s
1160 """ % (ipythondir,sys.exc_info()[1])
1160 """ % (ipythondir,sys.exc_info()[1])
1161 wait()
1161 wait()
1162 return
1162 return
1163 else:
1163 else:
1164 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
1164 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
1165 for new_full_path in sources:
1165 for new_full_path in sources:
1166 new_filename = os.path.basename(new_full_path)
1166 new_filename = os.path.basename(new_full_path)
1167 if new_filename.startswith('ipythonrc'):
1167 if new_filename.startswith('ipythonrc'):
1168 new_filename = new_filename + rc_suffix
1168 new_filename = new_filename + rc_suffix
1169 # The config directory should only contain files, skip any
1169 # The config directory should only contain files, skip any
1170 # directories which may be there (like CVS)
1170 # directories which may be there (like CVS)
1171 if os.path.isdir(new_full_path):
1171 if os.path.isdir(new_full_path):
1172 continue
1172 continue
1173 if os.path.exists(new_filename):
1173 if os.path.exists(new_filename):
1174 old_file = new_filename+'.old'
1174 old_file = new_filename+'.old'
1175 if os.path.exists(old_file):
1175 if os.path.exists(old_file):
1176 os.remove(old_file)
1176 os.remove(old_file)
1177 os.rename(new_filename,old_file)
1177 os.rename(new_filename,old_file)
1178 shutil.copy(new_full_path,new_filename)
1178 shutil.copy(new_full_path,new_filename)
1179 else:
1179 else:
1180 raise ValueError,'unrecognized mode for install:',`mode`
1180 raise ValueError,'unrecognized mode for install:',`mode`
1181
1181
1182 # Fix line-endings to those native to each platform in the config
1182 # Fix line-endings to those native to each platform in the config
1183 # directory.
1183 # directory.
1184 try:
1184 try:
1185 os.chdir(ipythondir)
1185 os.chdir(ipythondir)
1186 except:
1186 except:
1187 print """
1187 print """
1188 Problem: changing to directory %s failed.
1188 Problem: changing to directory %s failed.
1189 Details:
1189 Details:
1190 %s
1190 %s
1191
1191
1192 Some configuration files may have incorrect line endings. This should not
1192 Some configuration files may have incorrect line endings. This should not
1193 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
1193 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
1194 wait()
1194 wait()
1195 else:
1195 else:
1196 for fname in glb('ipythonrc*'):
1196 for fname in glb('ipythonrc*'):
1197 try:
1197 try:
1198 native_line_ends(fname,backup=0)
1198 native_line_ends(fname,backup=0)
1199 except IOError:
1199 except IOError:
1200 pass
1200 pass
1201
1201
1202 if mode == 'install':
1202 if mode == 'install':
1203 print """
1203 print """
1204 Successful installation!
1204 Successful installation!
1205
1205
1206 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
1206 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
1207 IPython manual (there are both HTML and PDF versions supplied with the
1207 IPython manual (there are both HTML and PDF versions supplied with the
1208 distribution) to make sure that your system environment is properly configured
1208 distribution) to make sure that your system environment is properly configured
1209 to take advantage of IPython's features.
1209 to take advantage of IPython's features.
1210
1210
1211 Important note: the configuration system has changed! The old system is
1211 Important note: the configuration system has changed! The old system is
1212 still in place, but its setting may be partly overridden by the settings in
1212 still in place, but its setting may be partly overridden by the settings in
1213 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
1213 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
1214 if some of the new settings bother you.
1214 if some of the new settings bother you.
1215
1215
1216 """
1216 """
1217 else:
1217 else:
1218 print """
1218 print """
1219 Successful upgrade!
1219 Successful upgrade!
1220
1220
1221 All files in your directory:
1221 All files in your directory:
1222 %(ipythondir)s
1222 %(ipythondir)s
1223 which would have been overwritten by the upgrade were backed up with a .old
1223 which would have been overwritten by the upgrade were backed up with a .old
1224 extension. If you had made particular customizations in those files you may
1224 extension. If you had made particular customizations in those files you may
1225 want to merge them back into the new files.""" % locals()
1225 want to merge them back into the new files.""" % locals()
1226 wait()
1226 wait()
1227 os.chdir(cwd)
1227 os.chdir(cwd)
1228 # end user_setup()
1228 # end user_setup()
1229
1229
1230 def atexit_operations(self):
1230 def atexit_operations(self):
1231 """This will be executed at the time of exit.
1231 """This will be executed at the time of exit.
1232
1232
1233 Saving of persistent data should be performed here. """
1233 Saving of persistent data should be performed here. """
1234
1234
1235 #print '*** IPython exit cleanup ***' # dbg
1235 #print '*** IPython exit cleanup ***' # dbg
1236 # input history
1236 # input history
1237 self.savehist()
1237 self.savehist()
1238
1238
1239 # Cleanup all tempfiles left around
1239 # Cleanup all tempfiles left around
1240 for tfile in self.tempfiles:
1240 for tfile in self.tempfiles:
1241 try:
1241 try:
1242 os.unlink(tfile)
1242 os.unlink(tfile)
1243 except OSError:
1243 except OSError:
1244 pass
1244 pass
1245
1245
1246 self.hooks.shutdown_hook()
1246 self.hooks.shutdown_hook()
1247
1247
1248 def savehist(self):
1248 def savehist(self):
1249 """Save input history to a file (via readline library)."""
1249 """Save input history to a file (via readline library)."""
1250
1251 if not self.has_readline:
1252 return
1253
1250 try:
1254 try:
1251 self.readline.write_history_file(self.histfile)
1255 self.readline.write_history_file(self.histfile)
1252 except:
1256 except:
1253 print 'Unable to save IPython command history to file: ' + \
1257 print 'Unable to save IPython command history to file: ' + \
1254 `self.histfile`
1258 `self.histfile`
1255
1259
1256 def reloadhist(self):
1260 def reloadhist(self):
1257 """Reload the input history from disk file."""
1261 """Reload the input history from disk file."""
1258
1262
1259 if self.has_readline:
1263 if self.has_readline:
1260 self.readline.clear_history()
1264 self.readline.clear_history()
1261 self.readline.read_history_file(self.shell.histfile)
1265 self.readline.read_history_file(self.shell.histfile)
1262
1266
1263 def history_saving_wrapper(self, func):
1267 def history_saving_wrapper(self, func):
1264 """ Wrap func for readline history saving
1268 """ Wrap func for readline history saving
1265
1269
1266 Convert func into callable that saves & restores
1270 Convert func into callable that saves & restores
1267 history around the call """
1271 history around the call """
1268
1272
1269 if not self.has_readline:
1273 if not self.has_readline:
1270 return func
1274 return func
1271
1275
1272 def wrapper():
1276 def wrapper():
1273 self.savehist()
1277 self.savehist()
1274 try:
1278 try:
1275 func()
1279 func()
1276 finally:
1280 finally:
1277 readline.read_history_file(self.histfile)
1281 readline.read_history_file(self.histfile)
1278 return wrapper
1282 return wrapper
1279
1283
1280
1284
1281 def pre_readline(self):
1285 def pre_readline(self):
1282 """readline hook to be used at the start of each line.
1286 """readline hook to be used at the start of each line.
1283
1287
1284 Currently it handles auto-indent only."""
1288 Currently it handles auto-indent only."""
1285
1289
1286 #debugx('self.indent_current_nsp','pre_readline:')
1290 #debugx('self.indent_current_nsp','pre_readline:')
1287
1291
1288 if self.rl_do_indent:
1292 if self.rl_do_indent:
1289 self.readline.insert_text(self.indent_current_str())
1293 self.readline.insert_text(self.indent_current_str())
1290 if self.rl_next_input is not None:
1294 if self.rl_next_input is not None:
1291 self.readline.insert_text(self.rl_next_input)
1295 self.readline.insert_text(self.rl_next_input)
1292 self.rl_next_input = None
1296 self.rl_next_input = None
1293
1297
1294 def init_readline(self):
1298 def init_readline(self):
1295 """Command history completion/saving/reloading."""
1299 """Command history completion/saving/reloading."""
1296
1300
1297
1301
1298 import IPython.rlineimpl as readline
1302 import IPython.rlineimpl as readline
1299
1303
1300 if not readline.have_readline:
1304 if not readline.have_readline:
1301 self.has_readline = 0
1305 self.has_readline = 0
1302 self.readline = None
1306 self.readline = None
1303 # no point in bugging windows users with this every time:
1307 # no point in bugging windows users with this every time:
1304 warn('Readline services not available on this platform.')
1308 warn('Readline services not available on this platform.')
1305 else:
1309 else:
1306 sys.modules['readline'] = readline
1310 sys.modules['readline'] = readline
1307 import atexit
1311 import atexit
1308 from IPython.completer import IPCompleter
1312 from IPython.completer import IPCompleter
1309 self.Completer = IPCompleter(self,
1313 self.Completer = IPCompleter(self,
1310 self.user_ns,
1314 self.user_ns,
1311 self.user_global_ns,
1315 self.user_global_ns,
1312 self.rc.readline_omit__names,
1316 self.rc.readline_omit__names,
1313 self.alias_table)
1317 self.alias_table)
1314 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1318 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1315 self.strdispatchers['complete_command'] = sdisp
1319 self.strdispatchers['complete_command'] = sdisp
1316 self.Completer.custom_completers = sdisp
1320 self.Completer.custom_completers = sdisp
1317 # Platform-specific configuration
1321 # Platform-specific configuration
1318 if os.name == 'nt':
1322 if os.name == 'nt':
1319 self.readline_startup_hook = readline.set_pre_input_hook
1323 self.readline_startup_hook = readline.set_pre_input_hook
1320 else:
1324 else:
1321 self.readline_startup_hook = readline.set_startup_hook
1325 self.readline_startup_hook = readline.set_startup_hook
1322
1326
1323 # Load user's initrc file (readline config)
1327 # Load user's initrc file (readline config)
1324 # Or if libedit is used, load editrc.
1328 # Or if libedit is used, load editrc.
1325 inputrc_name = os.environ.get('INPUTRC')
1329 inputrc_name = os.environ.get('INPUTRC')
1326 if inputrc_name is None:
1330 if inputrc_name is None:
1327 home_dir = get_home_dir()
1331 home_dir = get_home_dir()
1328 if home_dir is not None:
1332 if home_dir is not None:
1329 inputrc_name = '.inputrc'
1333 inputrc_name = '.inputrc'
1330 if readline.uses_libedit:
1334 if readline.uses_libedit:
1331 inputrc_name = '.editrc'
1335 inputrc_name = '.editrc'
1332 inputrc_name = os.path.join(home_dir, inputrc_name)
1336 inputrc_name = os.path.join(home_dir, inputrc_name)
1333 if os.path.isfile(inputrc_name):
1337 if os.path.isfile(inputrc_name):
1334 try:
1338 try:
1335 readline.read_init_file(inputrc_name)
1339 readline.read_init_file(inputrc_name)
1336 except:
1340 except:
1337 warn('Problems reading readline initialization file <%s>'
1341 warn('Problems reading readline initialization file <%s>'
1338 % inputrc_name)
1342 % inputrc_name)
1339
1343
1340 self.has_readline = 1
1344 self.has_readline = 1
1341 self.readline = readline
1345 self.readline = readline
1342 # save this in sys so embedded copies can restore it properly
1346 # save this in sys so embedded copies can restore it properly
1343 sys.ipcompleter = self.Completer.complete
1347 sys.ipcompleter = self.Completer.complete
1344 self.set_completer()
1348 self.set_completer()
1345
1349
1346 # Configure readline according to user's prefs
1350 # Configure readline according to user's prefs
1347 # This is only done if GNU readline is being used. If libedit
1351 # This is only done if GNU readline is being used. If libedit
1348 # is being used (as on Leopard) the readline config is
1352 # is being used (as on Leopard) the readline config is
1349 # not run as the syntax for libedit is different.
1353 # not run as the syntax for libedit is different.
1350 if not readline.uses_libedit:
1354 if not readline.uses_libedit:
1351 for rlcommand in self.rc.readline_parse_and_bind:
1355 for rlcommand in self.rc.readline_parse_and_bind:
1352 readline.parse_and_bind(rlcommand)
1356 readline.parse_and_bind(rlcommand)
1353
1357
1354 # remove some chars from the delimiters list
1358 # remove some chars from the delimiters list
1355 delims = readline.get_completer_delims()
1359 delims = readline.get_completer_delims()
1356 delims = delims.translate(string._idmap,
1360 delims = delims.translate(string._idmap,
1357 self.rc.readline_remove_delims)
1361 self.rc.readline_remove_delims)
1358 readline.set_completer_delims(delims)
1362 readline.set_completer_delims(delims)
1359 # otherwise we end up with a monster history after a while:
1363 # otherwise we end up with a monster history after a while:
1360 readline.set_history_length(1000)
1364 readline.set_history_length(1000)
1361 try:
1365 try:
1362 #print '*** Reading readline history' # dbg
1366 #print '*** Reading readline history' # dbg
1363 readline.read_history_file(self.histfile)
1367 readline.read_history_file(self.histfile)
1364 except IOError:
1368 except IOError:
1365 pass # It doesn't exist yet.
1369 pass # It doesn't exist yet.
1366
1370
1367 atexit.register(self.atexit_operations)
1371 atexit.register(self.atexit_operations)
1368 del atexit
1372 del atexit
1369
1373
1370 # Configure auto-indent for all platforms
1374 # Configure auto-indent for all platforms
1371 self.set_autoindent(self.rc.autoindent)
1375 self.set_autoindent(self.rc.autoindent)
1372
1376
1373 def ask_yes_no(self,prompt,default=True):
1377 def ask_yes_no(self,prompt,default=True):
1374 if self.rc.quiet:
1378 if self.rc.quiet:
1375 return True
1379 return True
1376 return ask_yes_no(prompt,default)
1380 return ask_yes_no(prompt,default)
1377
1381
1378 def _should_recompile(self,e):
1382 def _should_recompile(self,e):
1379 """Utility routine for edit_syntax_error"""
1383 """Utility routine for edit_syntax_error"""
1380
1384
1381 if e.filename in ('<ipython console>','<input>','<string>',
1385 if e.filename in ('<ipython console>','<input>','<string>',
1382 '<console>','<BackgroundJob compilation>',
1386 '<console>','<BackgroundJob compilation>',
1383 None):
1387 None):
1384
1388
1385 return False
1389 return False
1386 try:
1390 try:
1387 if (self.rc.autoedit_syntax and
1391 if (self.rc.autoedit_syntax and
1388 not self.ask_yes_no('Return to editor to correct syntax error? '
1392 not self.ask_yes_no('Return to editor to correct syntax error? '
1389 '[Y/n] ','y')):
1393 '[Y/n] ','y')):
1390 return False
1394 return False
1391 except EOFError:
1395 except EOFError:
1392 return False
1396 return False
1393
1397
1394 def int0(x):
1398 def int0(x):
1395 try:
1399 try:
1396 return int(x)
1400 return int(x)
1397 except TypeError:
1401 except TypeError:
1398 return 0
1402 return 0
1399 # always pass integer line and offset values to editor hook
1403 # always pass integer line and offset values to editor hook
1400 self.hooks.fix_error_editor(e.filename,
1404 self.hooks.fix_error_editor(e.filename,
1401 int0(e.lineno),int0(e.offset),e.msg)
1405 int0(e.lineno),int0(e.offset),e.msg)
1402 return True
1406 return True
1403
1407
1404 def edit_syntax_error(self):
1408 def edit_syntax_error(self):
1405 """The bottom half of the syntax error handler called in the main loop.
1409 """The bottom half of the syntax error handler called in the main loop.
1406
1410
1407 Loop until syntax error is fixed or user cancels.
1411 Loop until syntax error is fixed or user cancels.
1408 """
1412 """
1409
1413
1410 while self.SyntaxTB.last_syntax_error:
1414 while self.SyntaxTB.last_syntax_error:
1411 # copy and clear last_syntax_error
1415 # copy and clear last_syntax_error
1412 err = self.SyntaxTB.clear_err_state()
1416 err = self.SyntaxTB.clear_err_state()
1413 if not self._should_recompile(err):
1417 if not self._should_recompile(err):
1414 return
1418 return
1415 try:
1419 try:
1416 # may set last_syntax_error again if a SyntaxError is raised
1420 # may set last_syntax_error again if a SyntaxError is raised
1417 self.safe_execfile(err.filename,self.user_ns)
1421 self.safe_execfile(err.filename,self.user_ns)
1418 except:
1422 except:
1419 self.showtraceback()
1423 self.showtraceback()
1420 else:
1424 else:
1421 try:
1425 try:
1422 f = file(err.filename)
1426 f = file(err.filename)
1423 try:
1427 try:
1424 sys.displayhook(f.read())
1428 sys.displayhook(f.read())
1425 finally:
1429 finally:
1426 f.close()
1430 f.close()
1427 except:
1431 except:
1428 self.showtraceback()
1432 self.showtraceback()
1429
1433
1430 def showsyntaxerror(self, filename=None):
1434 def showsyntaxerror(self, filename=None):
1431 """Display the syntax error that just occurred.
1435 """Display the syntax error that just occurred.
1432
1436
1433 This doesn't display a stack trace because there isn't one.
1437 This doesn't display a stack trace because there isn't one.
1434
1438
1435 If a filename is given, it is stuffed in the exception instead
1439 If a filename is given, it is stuffed in the exception instead
1436 of what was there before (because Python's parser always uses
1440 of what was there before (because Python's parser always uses
1437 "<string>" when reading from a string).
1441 "<string>" when reading from a string).
1438 """
1442 """
1439 etype, value, last_traceback = sys.exc_info()
1443 etype, value, last_traceback = sys.exc_info()
1440
1444
1441 # See note about these variables in showtraceback() below
1445 # See note about these variables in showtraceback() below
1442 sys.last_type = etype
1446 sys.last_type = etype
1443 sys.last_value = value
1447 sys.last_value = value
1444 sys.last_traceback = last_traceback
1448 sys.last_traceback = last_traceback
1445
1449
1446 if filename and etype is SyntaxError:
1450 if filename and etype is SyntaxError:
1447 # Work hard to stuff the correct filename in the exception
1451 # Work hard to stuff the correct filename in the exception
1448 try:
1452 try:
1449 msg, (dummy_filename, lineno, offset, line) = value
1453 msg, (dummy_filename, lineno, offset, line) = value
1450 except:
1454 except:
1451 # Not the format we expect; leave it alone
1455 # Not the format we expect; leave it alone
1452 pass
1456 pass
1453 else:
1457 else:
1454 # Stuff in the right filename
1458 # Stuff in the right filename
1455 try:
1459 try:
1456 # Assume SyntaxError is a class exception
1460 # Assume SyntaxError is a class exception
1457 value = SyntaxError(msg, (filename, lineno, offset, line))
1461 value = SyntaxError(msg, (filename, lineno, offset, line))
1458 except:
1462 except:
1459 # If that failed, assume SyntaxError is a string
1463 # If that failed, assume SyntaxError is a string
1460 value = msg, (filename, lineno, offset, line)
1464 value = msg, (filename, lineno, offset, line)
1461 self.SyntaxTB(etype,value,[])
1465 self.SyntaxTB(etype,value,[])
1462
1466
1463 def debugger(self,force=False):
1467 def debugger(self,force=False):
1464 """Call the pydb/pdb debugger.
1468 """Call the pydb/pdb debugger.
1465
1469
1466 Keywords:
1470 Keywords:
1467
1471
1468 - force(False): by default, this routine checks the instance call_pdb
1472 - force(False): by default, this routine checks the instance call_pdb
1469 flag and does not actually invoke the debugger if the flag is false.
1473 flag and does not actually invoke the debugger if the flag is false.
1470 The 'force' option forces the debugger to activate even if the flag
1474 The 'force' option forces the debugger to activate even if the flag
1471 is false.
1475 is false.
1472 """
1476 """
1473
1477
1474 if not (force or self.call_pdb):
1478 if not (force or self.call_pdb):
1475 return
1479 return
1476
1480
1477 if not hasattr(sys,'last_traceback'):
1481 if not hasattr(sys,'last_traceback'):
1478 error('No traceback has been produced, nothing to debug.')
1482 error('No traceback has been produced, nothing to debug.')
1479 return
1483 return
1480
1484
1481 # use pydb if available
1485 # use pydb if available
1482 if Debugger.has_pydb:
1486 if Debugger.has_pydb:
1483 from pydb import pm
1487 from pydb import pm
1484 else:
1488 else:
1485 # fallback to our internal debugger
1489 # fallback to our internal debugger
1486 pm = lambda : self.InteractiveTB.debugger(force=True)
1490 pm = lambda : self.InteractiveTB.debugger(force=True)
1487 self.history_saving_wrapper(pm)()
1491 self.history_saving_wrapper(pm)()
1488
1492
1489 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1493 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1490 """Display the exception that just occurred.
1494 """Display the exception that just occurred.
1491
1495
1492 If nothing is known about the exception, this is the method which
1496 If nothing is known about the exception, this is the method which
1493 should be used throughout the code for presenting user tracebacks,
1497 should be used throughout the code for presenting user tracebacks,
1494 rather than directly invoking the InteractiveTB object.
1498 rather than directly invoking the InteractiveTB object.
1495
1499
1496 A specific showsyntaxerror() also exists, but this method can take
1500 A specific showsyntaxerror() also exists, but this method can take
1497 care of calling it if needed, so unless you are explicitly catching a
1501 care of calling it if needed, so unless you are explicitly catching a
1498 SyntaxError exception, don't try to analyze the stack manually and
1502 SyntaxError exception, don't try to analyze the stack manually and
1499 simply call this method."""
1503 simply call this method."""
1500
1504
1501
1505
1502 # Though this won't be called by syntax errors in the input line,
1506 # Though this won't be called by syntax errors in the input line,
1503 # there may be SyntaxError cases whith imported code.
1507 # there may be SyntaxError cases whith imported code.
1504
1508
1505
1509
1506 if exc_tuple is None:
1510 if exc_tuple is None:
1507 etype, value, tb = sys.exc_info()
1511 etype, value, tb = sys.exc_info()
1508 else:
1512 else:
1509 etype, value, tb = exc_tuple
1513 etype, value, tb = exc_tuple
1510
1514
1511 if etype is SyntaxError:
1515 if etype is SyntaxError:
1512 self.showsyntaxerror(filename)
1516 self.showsyntaxerror(filename)
1513 elif etype is IPython.ipapi.UsageError:
1517 elif etype is IPython.ipapi.UsageError:
1514 print "UsageError:", value
1518 print "UsageError:", value
1515 else:
1519 else:
1516 # WARNING: these variables are somewhat deprecated and not
1520 # WARNING: these variables are somewhat deprecated and not
1517 # necessarily safe to use in a threaded environment, but tools
1521 # necessarily safe to use in a threaded environment, but tools
1518 # like pdb depend on their existence, so let's set them. If we
1522 # like pdb depend on their existence, so let's set them. If we
1519 # find problems in the field, we'll need to revisit their use.
1523 # find problems in the field, we'll need to revisit their use.
1520 sys.last_type = etype
1524 sys.last_type = etype
1521 sys.last_value = value
1525 sys.last_value = value
1522 sys.last_traceback = tb
1526 sys.last_traceback = tb
1523
1527
1524 if etype in self.custom_exceptions:
1528 if etype in self.custom_exceptions:
1525 self.CustomTB(etype,value,tb)
1529 self.CustomTB(etype,value,tb)
1526 else:
1530 else:
1527 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1531 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1528 if self.InteractiveTB.call_pdb and self.has_readline:
1532 if self.InteractiveTB.call_pdb and self.has_readline:
1529 # pdb mucks up readline, fix it back
1533 # pdb mucks up readline, fix it back
1530 self.set_completer()
1534 self.set_completer()
1531
1535
1532
1536
1533 def mainloop(self,banner=None):
1537 def mainloop(self,banner=None):
1534 """Creates the local namespace and starts the mainloop.
1538 """Creates the local namespace and starts the mainloop.
1535
1539
1536 If an optional banner argument is given, it will override the
1540 If an optional banner argument is given, it will override the
1537 internally created default banner."""
1541 internally created default banner."""
1538
1542
1539 if self.rc.c: # Emulate Python's -c option
1543 if self.rc.c: # Emulate Python's -c option
1540 self.exec_init_cmd()
1544 self.exec_init_cmd()
1541 if banner is None:
1545 if banner is None:
1542 if not self.rc.banner:
1546 if not self.rc.banner:
1543 banner = ''
1547 banner = ''
1544 # banner is string? Use it directly!
1548 # banner is string? Use it directly!
1545 elif isinstance(self.rc.banner,basestring):
1549 elif isinstance(self.rc.banner,basestring):
1546 banner = self.rc.banner
1550 banner = self.rc.banner
1547 else:
1551 else:
1548 banner = self.BANNER+self.banner2
1552 banner = self.BANNER+self.banner2
1549
1553
1550 self.interact(banner)
1554 self.interact(banner)
1551
1555
1552 def exec_init_cmd(self):
1556 def exec_init_cmd(self):
1553 """Execute a command given at the command line.
1557 """Execute a command given at the command line.
1554
1558
1555 This emulates Python's -c option."""
1559 This emulates Python's -c option."""
1556
1560
1557 #sys.argv = ['-c']
1561 #sys.argv = ['-c']
1558 self.push(self.prefilter(self.rc.c, False))
1562 self.push(self.prefilter(self.rc.c, False))
1559 if not self.rc.interact:
1563 if not self.rc.interact:
1560 self.exit_now = True
1564 self.exit_now = True
1561
1565
1562 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1566 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1563 """Embeds IPython into a running python program.
1567 """Embeds IPython into a running python program.
1564
1568
1565 Input:
1569 Input:
1566
1570
1567 - header: An optional header message can be specified.
1571 - header: An optional header message can be specified.
1568
1572
1569 - local_ns, global_ns: working namespaces. If given as None, the
1573 - local_ns, global_ns: working namespaces. If given as None, the
1570 IPython-initialized one is updated with __main__.__dict__, so that
1574 IPython-initialized one is updated with __main__.__dict__, so that
1571 program variables become visible but user-specific configuration
1575 program variables become visible but user-specific configuration
1572 remains possible.
1576 remains possible.
1573
1577
1574 - stack_depth: specifies how many levels in the stack to go to
1578 - stack_depth: specifies how many levels in the stack to go to
1575 looking for namespaces (when local_ns and global_ns are None). This
1579 looking for namespaces (when local_ns and global_ns are None). This
1576 allows an intermediate caller to make sure that this function gets
1580 allows an intermediate caller to make sure that this function gets
1577 the namespace from the intended level in the stack. By default (0)
1581 the namespace from the intended level in the stack. By default (0)
1578 it will get its locals and globals from the immediate caller.
1582 it will get its locals and globals from the immediate caller.
1579
1583
1580 Warning: it's possible to use this in a program which is being run by
1584 Warning: it's possible to use this in a program which is being run by
1581 IPython itself (via %run), but some funny things will happen (a few
1585 IPython itself (via %run), but some funny things will happen (a few
1582 globals get overwritten). In the future this will be cleaned up, as
1586 globals get overwritten). In the future this will be cleaned up, as
1583 there is no fundamental reason why it can't work perfectly."""
1587 there is no fundamental reason why it can't work perfectly."""
1584
1588
1585 # Get locals and globals from caller
1589 # Get locals and globals from caller
1586 if local_ns is None or global_ns is None:
1590 if local_ns is None or global_ns is None:
1587 call_frame = sys._getframe(stack_depth).f_back
1591 call_frame = sys._getframe(stack_depth).f_back
1588
1592
1589 if local_ns is None:
1593 if local_ns is None:
1590 local_ns = call_frame.f_locals
1594 local_ns = call_frame.f_locals
1591 if global_ns is None:
1595 if global_ns is None:
1592 global_ns = call_frame.f_globals
1596 global_ns = call_frame.f_globals
1593
1597
1594 # Update namespaces and fire up interpreter
1598 # Update namespaces and fire up interpreter
1595
1599
1596 # The global one is easy, we can just throw it in
1600 # The global one is easy, we can just throw it in
1597 self.user_global_ns = global_ns
1601 self.user_global_ns = global_ns
1598
1602
1599 # but the user/local one is tricky: ipython needs it to store internal
1603 # but the user/local one is tricky: ipython needs it to store internal
1600 # data, but we also need the locals. We'll copy locals in the user
1604 # data, but we also need the locals. We'll copy locals in the user
1601 # one, but will track what got copied so we can delete them at exit.
1605 # one, but will track what got copied so we can delete them at exit.
1602 # This is so that a later embedded call doesn't see locals from a
1606 # This is so that a later embedded call doesn't see locals from a
1603 # previous call (which most likely existed in a separate scope).
1607 # previous call (which most likely existed in a separate scope).
1604 local_varnames = local_ns.keys()
1608 local_varnames = local_ns.keys()
1605 self.user_ns.update(local_ns)
1609 self.user_ns.update(local_ns)
1606
1610
1607 # Patch for global embedding to make sure that things don't overwrite
1611 # Patch for global embedding to make sure that things don't overwrite
1608 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1612 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1609 # FIXME. Test this a bit more carefully (the if.. is new)
1613 # FIXME. Test this a bit more carefully (the if.. is new)
1610 if local_ns is None and global_ns is None:
1614 if local_ns is None and global_ns is None:
1611 self.user_global_ns.update(__main__.__dict__)
1615 self.user_global_ns.update(__main__.__dict__)
1612
1616
1613 # make sure the tab-completer has the correct frame information, so it
1617 # make sure the tab-completer has the correct frame information, so it
1614 # actually completes using the frame's locals/globals
1618 # actually completes using the frame's locals/globals
1615 self.set_completer_frame()
1619 self.set_completer_frame()
1616
1620
1617 # before activating the interactive mode, we need to make sure that
1621 # before activating the interactive mode, we need to make sure that
1618 # all names in the builtin namespace needed by ipython point to
1622 # all names in the builtin namespace needed by ipython point to
1619 # ourselves, and not to other instances.
1623 # ourselves, and not to other instances.
1620 self.add_builtins()
1624 self.add_builtins()
1621
1625
1622 self.interact(header)
1626 self.interact(header)
1623
1627
1624 # now, purge out the user namespace from anything we might have added
1628 # now, purge out the user namespace from anything we might have added
1625 # from the caller's local namespace
1629 # from the caller's local namespace
1626 delvar = self.user_ns.pop
1630 delvar = self.user_ns.pop
1627 for var in local_varnames:
1631 for var in local_varnames:
1628 delvar(var,None)
1632 delvar(var,None)
1629 # and clean builtins we may have overridden
1633 # and clean builtins we may have overridden
1630 self.clean_builtins()
1634 self.clean_builtins()
1631
1635
1632 def interact(self, banner=None):
1636 def interact(self, banner=None):
1633 """Closely emulate the interactive Python console.
1637 """Closely emulate the interactive Python console.
1634
1638
1635 The optional banner argument specify the banner to print
1639 The optional banner argument specify the banner to print
1636 before the first interaction; by default it prints a banner
1640 before the first interaction; by default it prints a banner
1637 similar to the one printed by the real Python interpreter,
1641 similar to the one printed by the real Python interpreter,
1638 followed by the current class name in parentheses (so as not
1642 followed by the current class name in parentheses (so as not
1639 to confuse this with the real interpreter -- since it's so
1643 to confuse this with the real interpreter -- since it's so
1640 close!).
1644 close!).
1641
1645
1642 """
1646 """
1643
1647
1644 if self.exit_now:
1648 if self.exit_now:
1645 # batch run -> do not interact
1649 # batch run -> do not interact
1646 return
1650 return
1647 cprt = 'Type "copyright", "credits" or "license" for more information.'
1651 cprt = 'Type "copyright", "credits" or "license" for more information.'
1648 if banner is None:
1652 if banner is None:
1649 self.write("Python %s on %s\n%s\n(%s)\n" %
1653 self.write("Python %s on %s\n%s\n(%s)\n" %
1650 (sys.version, sys.platform, cprt,
1654 (sys.version, sys.platform, cprt,
1651 self.__class__.__name__))
1655 self.__class__.__name__))
1652 else:
1656 else:
1653 self.write(banner)
1657 self.write(banner)
1654
1658
1655 more = 0
1659 more = 0
1656
1660
1657 # Mark activity in the builtins
1661 # Mark activity in the builtins
1658 __builtin__.__dict__['__IPYTHON__active'] += 1
1662 __builtin__.__dict__['__IPYTHON__active'] += 1
1659
1663
1660 if self.has_readline:
1664 if self.has_readline:
1661 self.readline_startup_hook(self.pre_readline)
1665 self.readline_startup_hook(self.pre_readline)
1662 # exit_now is set by a call to %Exit or %Quit
1666 # exit_now is set by a call to %Exit or %Quit
1663
1667
1664 while not self.exit_now:
1668 while not self.exit_now:
1665 if more:
1669 if more:
1666 prompt = self.hooks.generate_prompt(True)
1670 prompt = self.hooks.generate_prompt(True)
1667 if self.autoindent:
1671 if self.autoindent:
1668 self.rl_do_indent = True
1672 self.rl_do_indent = True
1669
1673
1670 else:
1674 else:
1671 prompt = self.hooks.generate_prompt(False)
1675 prompt = self.hooks.generate_prompt(False)
1672 try:
1676 try:
1673 line = self.raw_input(prompt,more)
1677 line = self.raw_input(prompt,more)
1674 if self.exit_now:
1678 if self.exit_now:
1675 # quick exit on sys.std[in|out] close
1679 # quick exit on sys.std[in|out] close
1676 break
1680 break
1677 if self.autoindent:
1681 if self.autoindent:
1678 self.rl_do_indent = False
1682 self.rl_do_indent = False
1679
1683
1680 except KeyboardInterrupt:
1684 except KeyboardInterrupt:
1681 self.write('\nKeyboardInterrupt\n')
1685 self.write('\nKeyboardInterrupt\n')
1682 self.resetbuffer()
1686 self.resetbuffer()
1683 # keep cache in sync with the prompt counter:
1687 # keep cache in sync with the prompt counter:
1684 self.outputcache.prompt_count -= 1
1688 self.outputcache.prompt_count -= 1
1685
1689
1686 if self.autoindent:
1690 if self.autoindent:
1687 self.indent_current_nsp = 0
1691 self.indent_current_nsp = 0
1688 more = 0
1692 more = 0
1689 except EOFError:
1693 except EOFError:
1690 if self.autoindent:
1694 if self.autoindent:
1691 self.rl_do_indent = False
1695 self.rl_do_indent = False
1692 self.readline_startup_hook(None)
1696 self.readline_startup_hook(None)
1693 self.write('\n')
1697 self.write('\n')
1694 self.exit()
1698 self.exit()
1695 except bdb.BdbQuit:
1699 except bdb.BdbQuit:
1696 warn('The Python debugger has exited with a BdbQuit exception.\n'
1700 warn('The Python debugger has exited with a BdbQuit exception.\n'
1697 'Because of how pdb handles the stack, it is impossible\n'
1701 'Because of how pdb handles the stack, it is impossible\n'
1698 'for IPython to properly format this particular exception.\n'
1702 'for IPython to properly format this particular exception.\n'
1699 'IPython will resume normal operation.')
1703 'IPython will resume normal operation.')
1700 except:
1704 except:
1701 # exceptions here are VERY RARE, but they can be triggered
1705 # exceptions here are VERY RARE, but they can be triggered
1702 # asynchronously by signal handlers, for example.
1706 # asynchronously by signal handlers, for example.
1703 self.showtraceback()
1707 self.showtraceback()
1704 else:
1708 else:
1705 more = self.push(line)
1709 more = self.push(line)
1706 if (self.SyntaxTB.last_syntax_error and
1710 if (self.SyntaxTB.last_syntax_error and
1707 self.rc.autoedit_syntax):
1711 self.rc.autoedit_syntax):
1708 self.edit_syntax_error()
1712 self.edit_syntax_error()
1709
1713
1710 # We are off again...
1714 # We are off again...
1711 __builtin__.__dict__['__IPYTHON__active'] -= 1
1715 __builtin__.__dict__['__IPYTHON__active'] -= 1
1712
1716
1713 def excepthook(self, etype, value, tb):
1717 def excepthook(self, etype, value, tb):
1714 """One more defense for GUI apps that call sys.excepthook.
1718 """One more defense for GUI apps that call sys.excepthook.
1715
1719
1716 GUI frameworks like wxPython trap exceptions and call
1720 GUI frameworks like wxPython trap exceptions and call
1717 sys.excepthook themselves. I guess this is a feature that
1721 sys.excepthook themselves. I guess this is a feature that
1718 enables them to keep running after exceptions that would
1722 enables them to keep running after exceptions that would
1719 otherwise kill their mainloop. This is a bother for IPython
1723 otherwise kill their mainloop. This is a bother for IPython
1720 which excepts to catch all of the program exceptions with a try:
1724 which excepts to catch all of the program exceptions with a try:
1721 except: statement.
1725 except: statement.
1722
1726
1723 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1727 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1724 any app directly invokes sys.excepthook, it will look to the user like
1728 any app directly invokes sys.excepthook, it will look to the user like
1725 IPython crashed. In order to work around this, we can disable the
1729 IPython crashed. In order to work around this, we can disable the
1726 CrashHandler and replace it with this excepthook instead, which prints a
1730 CrashHandler and replace it with this excepthook instead, which prints a
1727 regular traceback using our InteractiveTB. In this fashion, apps which
1731 regular traceback using our InteractiveTB. In this fashion, apps which
1728 call sys.excepthook will generate a regular-looking exception from
1732 call sys.excepthook will generate a regular-looking exception from
1729 IPython, and the CrashHandler will only be triggered by real IPython
1733 IPython, and the CrashHandler will only be triggered by real IPython
1730 crashes.
1734 crashes.
1731
1735
1732 This hook should be used sparingly, only in places which are not likely
1736 This hook should be used sparingly, only in places which are not likely
1733 to be true IPython errors.
1737 to be true IPython errors.
1734 """
1738 """
1735 self.showtraceback((etype,value,tb),tb_offset=0)
1739 self.showtraceback((etype,value,tb),tb_offset=0)
1736
1740
1737 def expand_aliases(self,fn,rest):
1741 def expand_aliases(self,fn,rest):
1738 """ Expand multiple levels of aliases:
1742 """ Expand multiple levels of aliases:
1739
1743
1740 if:
1744 if:
1741
1745
1742 alias foo bar /tmp
1746 alias foo bar /tmp
1743 alias baz foo
1747 alias baz foo
1744
1748
1745 then:
1749 then:
1746
1750
1747 baz huhhahhei -> bar /tmp huhhahhei
1751 baz huhhahhei -> bar /tmp huhhahhei
1748
1752
1749 """
1753 """
1750 line = fn + " " + rest
1754 line = fn + " " + rest
1751
1755
1752 done = Set()
1756 done = Set()
1753 while 1:
1757 while 1:
1754 pre,fn,rest = prefilter.splitUserInput(line,
1758 pre,fn,rest = prefilter.splitUserInput(line,
1755 prefilter.shell_line_split)
1759 prefilter.shell_line_split)
1756 if fn in self.alias_table:
1760 if fn in self.alias_table:
1757 if fn in done:
1761 if fn in done:
1758 warn("Cyclic alias definition, repeated '%s'" % fn)
1762 warn("Cyclic alias definition, repeated '%s'" % fn)
1759 return ""
1763 return ""
1760 done.add(fn)
1764 done.add(fn)
1761
1765
1762 l2 = self.transform_alias(fn,rest)
1766 l2 = self.transform_alias(fn,rest)
1763 # dir -> dir
1767 # dir -> dir
1764 # print "alias",line, "->",l2 #dbg
1768 # print "alias",line, "->",l2 #dbg
1765 if l2 == line:
1769 if l2 == line:
1766 break
1770 break
1767 # ls -> ls -F should not recurse forever
1771 # ls -> ls -F should not recurse forever
1768 if l2.split(None,1)[0] == line.split(None,1)[0]:
1772 if l2.split(None,1)[0] == line.split(None,1)[0]:
1769 line = l2
1773 line = l2
1770 break
1774 break
1771
1775
1772 line=l2
1776 line=l2
1773
1777
1774
1778
1775 # print "al expand to",line #dbg
1779 # print "al expand to",line #dbg
1776 else:
1780 else:
1777 break
1781 break
1778
1782
1779 return line
1783 return line
1780
1784
1781 def transform_alias(self, alias,rest=''):
1785 def transform_alias(self, alias,rest=''):
1782 """ Transform alias to system command string.
1786 """ Transform alias to system command string.
1783 """
1787 """
1784 trg = self.alias_table[alias]
1788 trg = self.alias_table[alias]
1785
1789
1786 nargs,cmd = trg
1790 nargs,cmd = trg
1787 # print trg #dbg
1791 # print trg #dbg
1788 if ' ' in cmd and os.path.isfile(cmd):
1792 if ' ' in cmd and os.path.isfile(cmd):
1789 cmd = '"%s"' % cmd
1793 cmd = '"%s"' % cmd
1790
1794
1791 # Expand the %l special to be the user's input line
1795 # Expand the %l special to be the user's input line
1792 if cmd.find('%l') >= 0:
1796 if cmd.find('%l') >= 0:
1793 cmd = cmd.replace('%l',rest)
1797 cmd = cmd.replace('%l',rest)
1794 rest = ''
1798 rest = ''
1795 if nargs==0:
1799 if nargs==0:
1796 # Simple, argument-less aliases
1800 # Simple, argument-less aliases
1797 cmd = '%s %s' % (cmd,rest)
1801 cmd = '%s %s' % (cmd,rest)
1798 else:
1802 else:
1799 # Handle aliases with positional arguments
1803 # Handle aliases with positional arguments
1800 args = rest.split(None,nargs)
1804 args = rest.split(None,nargs)
1801 if len(args)< nargs:
1805 if len(args)< nargs:
1802 error('Alias <%s> requires %s arguments, %s given.' %
1806 error('Alias <%s> requires %s arguments, %s given.' %
1803 (alias,nargs,len(args)))
1807 (alias,nargs,len(args)))
1804 return None
1808 return None
1805 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1809 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1806 # Now call the macro, evaluating in the user's namespace
1810 # Now call the macro, evaluating in the user's namespace
1807 #print 'new command: <%r>' % cmd # dbg
1811 #print 'new command: <%r>' % cmd # dbg
1808 return cmd
1812 return cmd
1809
1813
1810 def call_alias(self,alias,rest=''):
1814 def call_alias(self,alias,rest=''):
1811 """Call an alias given its name and the rest of the line.
1815 """Call an alias given its name and the rest of the line.
1812
1816
1813 This is only used to provide backwards compatibility for users of
1817 This is only used to provide backwards compatibility for users of
1814 ipalias(), use of which is not recommended for anymore."""
1818 ipalias(), use of which is not recommended for anymore."""
1815
1819
1816 # Now call the macro, evaluating in the user's namespace
1820 # Now call the macro, evaluating in the user's namespace
1817 cmd = self.transform_alias(alias, rest)
1821 cmd = self.transform_alias(alias, rest)
1818 try:
1822 try:
1819 self.system(cmd)
1823 self.system(cmd)
1820 except:
1824 except:
1821 self.showtraceback()
1825 self.showtraceback()
1822
1826
1823 def indent_current_str(self):
1827 def indent_current_str(self):
1824 """return the current level of indentation as a string"""
1828 """return the current level of indentation as a string"""
1825 return self.indent_current_nsp * ' '
1829 return self.indent_current_nsp * ' '
1826
1830
1827 def autoindent_update(self,line):
1831 def autoindent_update(self,line):
1828 """Keep track of the indent level."""
1832 """Keep track of the indent level."""
1829
1833
1830 #debugx('line')
1834 #debugx('line')
1831 #debugx('self.indent_current_nsp')
1835 #debugx('self.indent_current_nsp')
1832 if self.autoindent:
1836 if self.autoindent:
1833 if line:
1837 if line:
1834 inisp = num_ini_spaces(line)
1838 inisp = num_ini_spaces(line)
1835 if inisp < self.indent_current_nsp:
1839 if inisp < self.indent_current_nsp:
1836 self.indent_current_nsp = inisp
1840 self.indent_current_nsp = inisp
1837
1841
1838 if line[-1] == ':':
1842 if line[-1] == ':':
1839 self.indent_current_nsp += 4
1843 self.indent_current_nsp += 4
1840 elif dedent_re.match(line):
1844 elif dedent_re.match(line):
1841 self.indent_current_nsp -= 4
1845 self.indent_current_nsp -= 4
1842 else:
1846 else:
1843 self.indent_current_nsp = 0
1847 self.indent_current_nsp = 0
1844
1848
1845 def runlines(self,lines):
1849 def runlines(self,lines):
1846 """Run a string of one or more lines of source.
1850 """Run a string of one or more lines of source.
1847
1851
1848 This method is capable of running a string containing multiple source
1852 This method is capable of running a string containing multiple source
1849 lines, as if they had been entered at the IPython prompt. Since it
1853 lines, as if they had been entered at the IPython prompt. Since it
1850 exposes IPython's processing machinery, the given strings can contain
1854 exposes IPython's processing machinery, the given strings can contain
1851 magic calls (%magic), special shell access (!cmd), etc."""
1855 magic calls (%magic), special shell access (!cmd), etc."""
1852
1856
1853 # We must start with a clean buffer, in case this is run from an
1857 # We must start with a clean buffer, in case this is run from an
1854 # interactive IPython session (via a magic, for example).
1858 # interactive IPython session (via a magic, for example).
1855 self.resetbuffer()
1859 self.resetbuffer()
1856 lines = lines.split('\n')
1860 lines = lines.split('\n')
1857 more = 0
1861 more = 0
1858
1862
1859 for line in lines:
1863 for line in lines:
1860 # skip blank lines so we don't mess up the prompt counter, but do
1864 # skip blank lines so we don't mess up the prompt counter, but do
1861 # NOT skip even a blank line if we are in a code block (more is
1865 # NOT skip even a blank line if we are in a code block (more is
1862 # true)
1866 # true)
1863
1867
1864
1868
1865 if line or more:
1869 if line or more:
1866 # push to raw history, so hist line numbers stay in sync
1870 # push to raw history, so hist line numbers stay in sync
1867 self.input_hist_raw.append("# " + line + "\n")
1871 self.input_hist_raw.append("# " + line + "\n")
1868 more = self.push(self.prefilter(line,more))
1872 more = self.push(self.prefilter(line,more))
1869 # IPython's runsource returns None if there was an error
1873 # IPython's runsource returns None if there was an error
1870 # compiling the code. This allows us to stop processing right
1874 # compiling the code. This allows us to stop processing right
1871 # away, so the user gets the error message at the right place.
1875 # away, so the user gets the error message at the right place.
1872 if more is None:
1876 if more is None:
1873 break
1877 break
1874 else:
1878 else:
1875 self.input_hist_raw.append("\n")
1879 self.input_hist_raw.append("\n")
1876 # final newline in case the input didn't have it, so that the code
1880 # final newline in case the input didn't have it, so that the code
1877 # actually does get executed
1881 # actually does get executed
1878 if more:
1882 if more:
1879 self.push('\n')
1883 self.push('\n')
1880
1884
1881 def runsource(self, source, filename='<input>', symbol='single'):
1885 def runsource(self, source, filename='<input>', symbol='single'):
1882 """Compile and run some source in the interpreter.
1886 """Compile and run some source in the interpreter.
1883
1887
1884 Arguments are as for compile_command().
1888 Arguments are as for compile_command().
1885
1889
1886 One several things can happen:
1890 One several things can happen:
1887
1891
1888 1) The input is incorrect; compile_command() raised an
1892 1) The input is incorrect; compile_command() raised an
1889 exception (SyntaxError or OverflowError). A syntax traceback
1893 exception (SyntaxError or OverflowError). A syntax traceback
1890 will be printed by calling the showsyntaxerror() method.
1894 will be printed by calling the showsyntaxerror() method.
1891
1895
1892 2) The input is incomplete, and more input is required;
1896 2) The input is incomplete, and more input is required;
1893 compile_command() returned None. Nothing happens.
1897 compile_command() returned None. Nothing happens.
1894
1898
1895 3) The input is complete; compile_command() returned a code
1899 3) The input is complete; compile_command() returned a code
1896 object. The code is executed by calling self.runcode() (which
1900 object. The code is executed by calling self.runcode() (which
1897 also handles run-time exceptions, except for SystemExit).
1901 also handles run-time exceptions, except for SystemExit).
1898
1902
1899 The return value is:
1903 The return value is:
1900
1904
1901 - True in case 2
1905 - True in case 2
1902
1906
1903 - False in the other cases, unless an exception is raised, where
1907 - False in the other cases, unless an exception is raised, where
1904 None is returned instead. This can be used by external callers to
1908 None is returned instead. This can be used by external callers to
1905 know whether to continue feeding input or not.
1909 know whether to continue feeding input or not.
1906
1910
1907 The return value can be used to decide whether to use sys.ps1 or
1911 The return value can be used to decide whether to use sys.ps1 or
1908 sys.ps2 to prompt the next line."""
1912 sys.ps2 to prompt the next line."""
1909
1913
1910 # if the source code has leading blanks, add 'if 1:\n' to it
1914 # if the source code has leading blanks, add 'if 1:\n' to it
1911 # this allows execution of indented pasted code. It is tempting
1915 # this allows execution of indented pasted code. It is tempting
1912 # to add '\n' at the end of source to run commands like ' a=1'
1916 # to add '\n' at the end of source to run commands like ' a=1'
1913 # directly, but this fails for more complicated scenarios
1917 # directly, but this fails for more complicated scenarios
1914 source=source.encode(self.stdin_encoding)
1918 source=source.encode(self.stdin_encoding)
1915 if source[:1] in [' ', '\t']:
1919 if source[:1] in [' ', '\t']:
1916 source = 'if 1:\n%s' % source
1920 source = 'if 1:\n%s' % source
1917
1921
1918 try:
1922 try:
1919 code = self.compile(source,filename,symbol)
1923 code = self.compile(source,filename,symbol)
1920 except (OverflowError, SyntaxError, ValueError):
1924 except (OverflowError, SyntaxError, ValueError):
1921 # Case 1
1925 # Case 1
1922 self.showsyntaxerror(filename)
1926 self.showsyntaxerror(filename)
1923 return None
1927 return None
1924
1928
1925 if code is None:
1929 if code is None:
1926 # Case 2
1930 # Case 2
1927 return True
1931 return True
1928
1932
1929 # Case 3
1933 # Case 3
1930 # We store the code object so that threaded shells and
1934 # We store the code object so that threaded shells and
1931 # custom exception handlers can access all this info if needed.
1935 # custom exception handlers can access all this info if needed.
1932 # The source corresponding to this can be obtained from the
1936 # The source corresponding to this can be obtained from the
1933 # buffer attribute as '\n'.join(self.buffer).
1937 # buffer attribute as '\n'.join(self.buffer).
1934 self.code_to_run = code
1938 self.code_to_run = code
1935 # now actually execute the code object
1939 # now actually execute the code object
1936 if self.runcode(code) == 0:
1940 if self.runcode(code) == 0:
1937 return False
1941 return False
1938 else:
1942 else:
1939 return None
1943 return None
1940
1944
1941 def runcode(self,code_obj):
1945 def runcode(self,code_obj):
1942 """Execute a code object.
1946 """Execute a code object.
1943
1947
1944 When an exception occurs, self.showtraceback() is called to display a
1948 When an exception occurs, self.showtraceback() is called to display a
1945 traceback.
1949 traceback.
1946
1950
1947 Return value: a flag indicating whether the code to be run completed
1951 Return value: a flag indicating whether the code to be run completed
1948 successfully:
1952 successfully:
1949
1953
1950 - 0: successful execution.
1954 - 0: successful execution.
1951 - 1: an error occurred.
1955 - 1: an error occurred.
1952 """
1956 """
1953
1957
1954 # Set our own excepthook in case the user code tries to call it
1958 # Set our own excepthook in case the user code tries to call it
1955 # directly, so that the IPython crash handler doesn't get triggered
1959 # directly, so that the IPython crash handler doesn't get triggered
1956 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1960 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1957
1961
1958 # we save the original sys.excepthook in the instance, in case config
1962 # we save the original sys.excepthook in the instance, in case config
1959 # code (such as magics) needs access to it.
1963 # code (such as magics) needs access to it.
1960 self.sys_excepthook = old_excepthook
1964 self.sys_excepthook = old_excepthook
1961 outflag = 1 # happens in more places, so it's easier as default
1965 outflag = 1 # happens in more places, so it's easier as default
1962 try:
1966 try:
1963 try:
1967 try:
1964 # Embedded instances require separate global/local namespaces
1968 # Embedded instances require separate global/local namespaces
1965 # so they can see both the surrounding (local) namespace and
1969 # so they can see both the surrounding (local) namespace and
1966 # the module-level globals when called inside another function.
1970 # the module-level globals when called inside another function.
1967 if self.embedded:
1971 if self.embedded:
1968 exec code_obj in self.user_global_ns, self.user_ns
1972 exec code_obj in self.user_global_ns, self.user_ns
1969 # Normal (non-embedded) instances should only have a single
1973 # Normal (non-embedded) instances should only have a single
1970 # namespace for user code execution, otherwise functions won't
1974 # namespace for user code execution, otherwise functions won't
1971 # see interactive top-level globals.
1975 # see interactive top-level globals.
1972 else:
1976 else:
1973 exec code_obj in self.user_ns
1977 exec code_obj in self.user_ns
1974 finally:
1978 finally:
1975 # Reset our crash handler in place
1979 # Reset our crash handler in place
1976 sys.excepthook = old_excepthook
1980 sys.excepthook = old_excepthook
1977 except SystemExit:
1981 except SystemExit:
1978 self.resetbuffer()
1982 self.resetbuffer()
1979 self.showtraceback()
1983 self.showtraceback()
1980 warn("Type %exit or %quit to exit IPython "
1984 warn("Type %exit or %quit to exit IPython "
1981 "(%Exit or %Quit do so unconditionally).",level=1)
1985 "(%Exit or %Quit do so unconditionally).",level=1)
1982 except self.custom_exceptions:
1986 except self.custom_exceptions:
1983 etype,value,tb = sys.exc_info()
1987 etype,value,tb = sys.exc_info()
1984 self.CustomTB(etype,value,tb)
1988 self.CustomTB(etype,value,tb)
1985 except:
1989 except:
1986 self.showtraceback()
1990 self.showtraceback()
1987 else:
1991 else:
1988 outflag = 0
1992 outflag = 0
1989 if softspace(sys.stdout, 0):
1993 if softspace(sys.stdout, 0):
1990 print
1994 print
1991 # Flush out code object which has been run (and source)
1995 # Flush out code object which has been run (and source)
1992 self.code_to_run = None
1996 self.code_to_run = None
1993 return outflag
1997 return outflag
1994
1998
1995 def push(self, line):
1999 def push(self, line):
1996 """Push a line to the interpreter.
2000 """Push a line to the interpreter.
1997
2001
1998 The line should not have a trailing newline; it may have
2002 The line should not have a trailing newline; it may have
1999 internal newlines. The line is appended to a buffer and the
2003 internal newlines. The line is appended to a buffer and the
2000 interpreter's runsource() method is called with the
2004 interpreter's runsource() method is called with the
2001 concatenated contents of the buffer as source. If this
2005 concatenated contents of the buffer as source. If this
2002 indicates that the command was executed or invalid, the buffer
2006 indicates that the command was executed or invalid, the buffer
2003 is reset; otherwise, the command is incomplete, and the buffer
2007 is reset; otherwise, the command is incomplete, and the buffer
2004 is left as it was after the line was appended. The return
2008 is left as it was after the line was appended. The return
2005 value is 1 if more input is required, 0 if the line was dealt
2009 value is 1 if more input is required, 0 if the line was dealt
2006 with in some way (this is the same as runsource()).
2010 with in some way (this is the same as runsource()).
2007 """
2011 """
2008
2012
2009 # autoindent management should be done here, and not in the
2013 # autoindent management should be done here, and not in the
2010 # interactive loop, since that one is only seen by keyboard input. We
2014 # interactive loop, since that one is only seen by keyboard input. We
2011 # need this done correctly even for code run via runlines (which uses
2015 # need this done correctly even for code run via runlines (which uses
2012 # push).
2016 # push).
2013
2017
2014 #print 'push line: <%s>' % line # dbg
2018 #print 'push line: <%s>' % line # dbg
2015 for subline in line.splitlines():
2019 for subline in line.splitlines():
2016 self.autoindent_update(subline)
2020 self.autoindent_update(subline)
2017 self.buffer.append(line)
2021 self.buffer.append(line)
2018 more = self.runsource('\n'.join(self.buffer), self.filename)
2022 more = self.runsource('\n'.join(self.buffer), self.filename)
2019 if not more:
2023 if not more:
2020 self.resetbuffer()
2024 self.resetbuffer()
2021 return more
2025 return more
2022
2026
2023 def split_user_input(self, line):
2027 def split_user_input(self, line):
2024 # This is really a hold-over to support ipapi and some extensions
2028 # This is really a hold-over to support ipapi and some extensions
2025 return prefilter.splitUserInput(line)
2029 return prefilter.splitUserInput(line)
2026
2030
2027 def resetbuffer(self):
2031 def resetbuffer(self):
2028 """Reset the input buffer."""
2032 """Reset the input buffer."""
2029 self.buffer[:] = []
2033 self.buffer[:] = []
2030
2034
2031 def raw_input(self,prompt='',continue_prompt=False):
2035 def raw_input(self,prompt='',continue_prompt=False):
2032 """Write a prompt and read a line.
2036 """Write a prompt and read a line.
2033
2037
2034 The returned line does not include the trailing newline.
2038 The returned line does not include the trailing newline.
2035 When the user enters the EOF key sequence, EOFError is raised.
2039 When the user enters the EOF key sequence, EOFError is raised.
2036
2040
2037 Optional inputs:
2041 Optional inputs:
2038
2042
2039 - prompt(''): a string to be printed to prompt the user.
2043 - prompt(''): a string to be printed to prompt the user.
2040
2044
2041 - continue_prompt(False): whether this line is the first one or a
2045 - continue_prompt(False): whether this line is the first one or a
2042 continuation in a sequence of inputs.
2046 continuation in a sequence of inputs.
2043 """
2047 """
2044
2048
2045 # Code run by the user may have modified the readline completer state.
2049 # Code run by the user may have modified the readline completer state.
2046 # We must ensure that our completer is back in place.
2050 # We must ensure that our completer is back in place.
2047 if self.has_readline:
2051 if self.has_readline:
2048 self.set_completer()
2052 self.set_completer()
2049
2053
2050 try:
2054 try:
2051 line = raw_input_original(prompt).decode(self.stdin_encoding)
2055 line = raw_input_original(prompt).decode(self.stdin_encoding)
2052 except ValueError:
2056 except ValueError:
2053 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2057 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2054 " or sys.stdout.close()!\nExiting IPython!")
2058 " or sys.stdout.close()!\nExiting IPython!")
2055 self.exit_now = True
2059 self.exit_now = True
2056 return ""
2060 return ""
2057
2061
2058 # Try to be reasonably smart about not re-indenting pasted input more
2062 # Try to be reasonably smart about not re-indenting pasted input more
2059 # than necessary. We do this by trimming out the auto-indent initial
2063 # than necessary. We do this by trimming out the auto-indent initial
2060 # spaces, if the user's actual input started itself with whitespace.
2064 # spaces, if the user's actual input started itself with whitespace.
2061 #debugx('self.buffer[-1]')
2065 #debugx('self.buffer[-1]')
2062
2066
2063 if self.autoindent:
2067 if self.autoindent:
2064 if num_ini_spaces(line) > self.indent_current_nsp:
2068 if num_ini_spaces(line) > self.indent_current_nsp:
2065 line = line[self.indent_current_nsp:]
2069 line = line[self.indent_current_nsp:]
2066 self.indent_current_nsp = 0
2070 self.indent_current_nsp = 0
2067
2071
2068 # store the unfiltered input before the user has any chance to modify
2072 # store the unfiltered input before the user has any chance to modify
2069 # it.
2073 # it.
2070 if line.strip():
2074 if line.strip():
2071 if continue_prompt:
2075 if continue_prompt:
2072 self.input_hist_raw[-1] += '%s\n' % line
2076 self.input_hist_raw[-1] += '%s\n' % line
2073 if self.has_readline: # and some config option is set?
2077 if self.has_readline: # and some config option is set?
2074 try:
2078 try:
2075 histlen = self.readline.get_current_history_length()
2079 histlen = self.readline.get_current_history_length()
2076 newhist = self.input_hist_raw[-1].rstrip()
2080 newhist = self.input_hist_raw[-1].rstrip()
2077 self.readline.remove_history_item(histlen-1)
2081 self.readline.remove_history_item(histlen-1)
2078 self.readline.replace_history_item(histlen-2,
2082 self.readline.replace_history_item(histlen-2,
2079 newhist.encode(self.stdin_encoding))
2083 newhist.encode(self.stdin_encoding))
2080 except AttributeError:
2084 except AttributeError:
2081 pass # re{move,place}_history_item are new in 2.4.
2085 pass # re{move,place}_history_item are new in 2.4.
2082 else:
2086 else:
2083 self.input_hist_raw.append('%s\n' % line)
2087 self.input_hist_raw.append('%s\n' % line)
2084 # only entries starting at first column go to shadow history
2088 # only entries starting at first column go to shadow history
2085 if line.lstrip() == line:
2089 if line.lstrip() == line:
2086 self.shadowhist.add(line.strip())
2090 self.shadowhist.add(line.strip())
2087 elif not continue_prompt:
2091 elif not continue_prompt:
2088 self.input_hist_raw.append('\n')
2092 self.input_hist_raw.append('\n')
2089 try:
2093 try:
2090 lineout = self.prefilter(line,continue_prompt)
2094 lineout = self.prefilter(line,continue_prompt)
2091 except:
2095 except:
2092 # blanket except, in case a user-defined prefilter crashes, so it
2096 # blanket except, in case a user-defined prefilter crashes, so it
2093 # can't take all of ipython with it.
2097 # can't take all of ipython with it.
2094 self.showtraceback()
2098 self.showtraceback()
2095 return ''
2099 return ''
2096 else:
2100 else:
2097 return lineout
2101 return lineout
2098
2102
2099 def _prefilter(self, line, continue_prompt):
2103 def _prefilter(self, line, continue_prompt):
2100 """Calls different preprocessors, depending on the form of line."""
2104 """Calls different preprocessors, depending on the form of line."""
2101
2105
2102 # All handlers *must* return a value, even if it's blank ('').
2106 # All handlers *must* return a value, even if it's blank ('').
2103
2107
2104 # Lines are NOT logged here. Handlers should process the line as
2108 # Lines are NOT logged here. Handlers should process the line as
2105 # needed, update the cache AND log it (so that the input cache array
2109 # needed, update the cache AND log it (so that the input cache array
2106 # stays synced).
2110 # stays synced).
2107
2111
2108 #.....................................................................
2112 #.....................................................................
2109 # Code begins
2113 # Code begins
2110
2114
2111 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2115 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2112
2116
2113 # save the line away in case we crash, so the post-mortem handler can
2117 # save the line away in case we crash, so the post-mortem handler can
2114 # record it
2118 # record it
2115 self._last_input_line = line
2119 self._last_input_line = line
2116
2120
2117 #print '***line: <%s>' % line # dbg
2121 #print '***line: <%s>' % line # dbg
2118
2122
2119 if not line:
2123 if not line:
2120 # Return immediately on purely empty lines, so that if the user
2124 # Return immediately on purely empty lines, so that if the user
2121 # previously typed some whitespace that started a continuation
2125 # previously typed some whitespace that started a continuation
2122 # prompt, he can break out of that loop with just an empty line.
2126 # prompt, he can break out of that loop with just an empty line.
2123 # This is how the default python prompt works.
2127 # This is how the default python prompt works.
2124
2128
2125 # Only return if the accumulated input buffer was just whitespace!
2129 # Only return if the accumulated input buffer was just whitespace!
2126 if ''.join(self.buffer).isspace():
2130 if ''.join(self.buffer).isspace():
2127 self.buffer[:] = []
2131 self.buffer[:] = []
2128 return ''
2132 return ''
2129
2133
2130 line_info = prefilter.LineInfo(line, continue_prompt)
2134 line_info = prefilter.LineInfo(line, continue_prompt)
2131
2135
2132 # the input history needs to track even empty lines
2136 # the input history needs to track even empty lines
2133 stripped = line.strip()
2137 stripped = line.strip()
2134
2138
2135 if not stripped:
2139 if not stripped:
2136 if not continue_prompt:
2140 if not continue_prompt:
2137 self.outputcache.prompt_count -= 1
2141 self.outputcache.prompt_count -= 1
2138 return self.handle_normal(line_info)
2142 return self.handle_normal(line_info)
2139
2143
2140 # print '***cont',continue_prompt # dbg
2144 # print '***cont',continue_prompt # dbg
2141 # special handlers are only allowed for single line statements
2145 # special handlers are only allowed for single line statements
2142 if continue_prompt and not self.rc.multi_line_specials:
2146 if continue_prompt and not self.rc.multi_line_specials:
2143 return self.handle_normal(line_info)
2147 return self.handle_normal(line_info)
2144
2148
2145
2149
2146 # See whether any pre-existing handler can take care of it
2150 # See whether any pre-existing handler can take care of it
2147 rewritten = self.hooks.input_prefilter(stripped)
2151 rewritten = self.hooks.input_prefilter(stripped)
2148 if rewritten != stripped: # ok, some prefilter did something
2152 if rewritten != stripped: # ok, some prefilter did something
2149 rewritten = line_info.pre + rewritten # add indentation
2153 rewritten = line_info.pre + rewritten # add indentation
2150 return self.handle_normal(prefilter.LineInfo(rewritten,
2154 return self.handle_normal(prefilter.LineInfo(rewritten,
2151 continue_prompt))
2155 continue_prompt))
2152
2156
2153 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2157 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2154
2158
2155 return prefilter.prefilter(line_info, self)
2159 return prefilter.prefilter(line_info, self)
2156
2160
2157
2161
2158 def _prefilter_dumb(self, line, continue_prompt):
2162 def _prefilter_dumb(self, line, continue_prompt):
2159 """simple prefilter function, for debugging"""
2163 """simple prefilter function, for debugging"""
2160 return self.handle_normal(line,continue_prompt)
2164 return self.handle_normal(line,continue_prompt)
2161
2165
2162
2166
2163 def multiline_prefilter(self, line, continue_prompt):
2167 def multiline_prefilter(self, line, continue_prompt):
2164 """ Run _prefilter for each line of input
2168 """ Run _prefilter for each line of input
2165
2169
2166 Covers cases where there are multiple lines in the user entry,
2170 Covers cases where there are multiple lines in the user entry,
2167 which is the case when the user goes back to a multiline history
2171 which is the case when the user goes back to a multiline history
2168 entry and presses enter.
2172 entry and presses enter.
2169
2173
2170 """
2174 """
2171 out = []
2175 out = []
2172 for l in line.rstrip('\n').split('\n'):
2176 for l in line.rstrip('\n').split('\n'):
2173 out.append(self._prefilter(l, continue_prompt))
2177 out.append(self._prefilter(l, continue_prompt))
2174 return '\n'.join(out)
2178 return '\n'.join(out)
2175
2179
2176 # Set the default prefilter() function (this can be user-overridden)
2180 # Set the default prefilter() function (this can be user-overridden)
2177 prefilter = multiline_prefilter
2181 prefilter = multiline_prefilter
2178
2182
2179 def handle_normal(self,line_info):
2183 def handle_normal(self,line_info):
2180 """Handle normal input lines. Use as a template for handlers."""
2184 """Handle normal input lines. Use as a template for handlers."""
2181
2185
2182 # With autoindent on, we need some way to exit the input loop, and I
2186 # With autoindent on, we need some way to exit the input loop, and I
2183 # don't want to force the user to have to backspace all the way to
2187 # don't want to force the user to have to backspace all the way to
2184 # clear the line. The rule will be in this case, that either two
2188 # clear the line. The rule will be in this case, that either two
2185 # lines of pure whitespace in a row, or a line of pure whitespace but
2189 # lines of pure whitespace in a row, or a line of pure whitespace but
2186 # of a size different to the indent level, will exit the input loop.
2190 # of a size different to the indent level, will exit the input loop.
2187 line = line_info.line
2191 line = line_info.line
2188 continue_prompt = line_info.continue_prompt
2192 continue_prompt = line_info.continue_prompt
2189
2193
2190 if (continue_prompt and self.autoindent and line.isspace() and
2194 if (continue_prompt and self.autoindent and line.isspace() and
2191 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2195 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2192 (self.buffer[-1]).isspace() )):
2196 (self.buffer[-1]).isspace() )):
2193 line = ''
2197 line = ''
2194
2198
2195 self.log(line,line,continue_prompt)
2199 self.log(line,line,continue_prompt)
2196 return line
2200 return line
2197
2201
2198 def handle_alias(self,line_info):
2202 def handle_alias(self,line_info):
2199 """Handle alias input lines. """
2203 """Handle alias input lines. """
2200 tgt = self.alias_table[line_info.iFun]
2204 tgt = self.alias_table[line_info.iFun]
2201 # print "=>",tgt #dbg
2205 # print "=>",tgt #dbg
2202 if callable(tgt):
2206 if callable(tgt):
2203 if '$' in line_info.line:
2207 if '$' in line_info.line:
2204 call_meth = '(_ip, _ip.itpl(%s))'
2208 call_meth = '(_ip, _ip.itpl(%s))'
2205 else:
2209 else:
2206 call_meth = '(_ip,%s)'
2210 call_meth = '(_ip,%s)'
2207 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2211 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2208 line_info.iFun,
2212 line_info.iFun,
2209 make_quoted_expr(line_info.line))
2213 make_quoted_expr(line_info.line))
2210 else:
2214 else:
2211 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2215 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2212
2216
2213 # pre is needed, because it carries the leading whitespace. Otherwise
2217 # pre is needed, because it carries the leading whitespace. Otherwise
2214 # aliases won't work in indented sections.
2218 # aliases won't work in indented sections.
2215 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2219 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2216 make_quoted_expr( transformed ))
2220 make_quoted_expr( transformed ))
2217
2221
2218 self.log(line_info.line,line_out,line_info.continue_prompt)
2222 self.log(line_info.line,line_out,line_info.continue_prompt)
2219 #print 'line out:',line_out # dbg
2223 #print 'line out:',line_out # dbg
2220 return line_out
2224 return line_out
2221
2225
2222 def handle_shell_escape(self, line_info):
2226 def handle_shell_escape(self, line_info):
2223 """Execute the line in a shell, empty return value"""
2227 """Execute the line in a shell, empty return value"""
2224 #print 'line in :', `line` # dbg
2228 #print 'line in :', `line` # dbg
2225 line = line_info.line
2229 line = line_info.line
2226 if line.lstrip().startswith('!!'):
2230 if line.lstrip().startswith('!!'):
2227 # rewrite LineInfo's line, iFun and theRest to properly hold the
2231 # rewrite LineInfo's line, iFun and theRest to properly hold the
2228 # call to %sx and the actual command to be executed, so
2232 # call to %sx and the actual command to be executed, so
2229 # handle_magic can work correctly. Note that this works even if
2233 # handle_magic can work correctly. Note that this works even if
2230 # the line is indented, so it handles multi_line_specials
2234 # the line is indented, so it handles multi_line_specials
2231 # properly.
2235 # properly.
2232 new_rest = line.lstrip()[2:]
2236 new_rest = line.lstrip()[2:]
2233 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2237 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2234 line_info.iFun = 'sx'
2238 line_info.iFun = 'sx'
2235 line_info.theRest = new_rest
2239 line_info.theRest = new_rest
2236 return self.handle_magic(line_info)
2240 return self.handle_magic(line_info)
2237 else:
2241 else:
2238 cmd = line.lstrip().lstrip('!')
2242 cmd = line.lstrip().lstrip('!')
2239 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2243 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2240 make_quoted_expr(cmd))
2244 make_quoted_expr(cmd))
2241 # update cache/log and return
2245 # update cache/log and return
2242 self.log(line,line_out,line_info.continue_prompt)
2246 self.log(line,line_out,line_info.continue_prompt)
2243 return line_out
2247 return line_out
2244
2248
2245 def handle_magic(self, line_info):
2249 def handle_magic(self, line_info):
2246 """Execute magic functions."""
2250 """Execute magic functions."""
2247 iFun = line_info.iFun
2251 iFun = line_info.iFun
2248 theRest = line_info.theRest
2252 theRest = line_info.theRest
2249 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2253 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2250 make_quoted_expr(iFun + " " + theRest))
2254 make_quoted_expr(iFun + " " + theRest))
2251 self.log(line_info.line,cmd,line_info.continue_prompt)
2255 self.log(line_info.line,cmd,line_info.continue_prompt)
2252 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2256 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2253 return cmd
2257 return cmd
2254
2258
2255 def handle_auto(self, line_info):
2259 def handle_auto(self, line_info):
2256 """Hande lines which can be auto-executed, quoting if requested."""
2260 """Hande lines which can be auto-executed, quoting if requested."""
2257
2261
2258 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2262 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2259 line = line_info.line
2263 line = line_info.line
2260 iFun = line_info.iFun
2264 iFun = line_info.iFun
2261 theRest = line_info.theRest
2265 theRest = line_info.theRest
2262 pre = line_info.pre
2266 pre = line_info.pre
2263 continue_prompt = line_info.continue_prompt
2267 continue_prompt = line_info.continue_prompt
2264 obj = line_info.ofind(self)['obj']
2268 obj = line_info.ofind(self)['obj']
2265
2269
2266 # This should only be active for single-line input!
2270 # This should only be active for single-line input!
2267 if continue_prompt:
2271 if continue_prompt:
2268 self.log(line,line,continue_prompt)
2272 self.log(line,line,continue_prompt)
2269 return line
2273 return line
2270
2274
2271 force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
2275 force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
2272 auto_rewrite = True
2276 auto_rewrite = True
2273
2277
2274 if pre == self.ESC_QUOTE:
2278 if pre == self.ESC_QUOTE:
2275 # Auto-quote splitting on whitespace
2279 # Auto-quote splitting on whitespace
2276 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2280 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2277 elif pre == self.ESC_QUOTE2:
2281 elif pre == self.ESC_QUOTE2:
2278 # Auto-quote whole string
2282 # Auto-quote whole string
2279 newcmd = '%s("%s")' % (iFun,theRest)
2283 newcmd = '%s("%s")' % (iFun,theRest)
2280 elif pre == self.ESC_PAREN:
2284 elif pre == self.ESC_PAREN:
2281 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2285 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2282 else:
2286 else:
2283 # Auto-paren.
2287 # Auto-paren.
2284 # We only apply it to argument-less calls if the autocall
2288 # We only apply it to argument-less calls if the autocall
2285 # parameter is set to 2. We only need to check that autocall is <
2289 # parameter is set to 2. We only need to check that autocall is <
2286 # 2, since this function isn't called unless it's at least 1.
2290 # 2, since this function isn't called unless it's at least 1.
2287 if not theRest and (self.rc.autocall < 2) and not force_auto:
2291 if not theRest and (self.rc.autocall < 2) and not force_auto:
2288 newcmd = '%s %s' % (iFun,theRest)
2292 newcmd = '%s %s' % (iFun,theRest)
2289 auto_rewrite = False
2293 auto_rewrite = False
2290 else:
2294 else:
2291 if not force_auto and theRest.startswith('['):
2295 if not force_auto and theRest.startswith('['):
2292 if hasattr(obj,'__getitem__'):
2296 if hasattr(obj,'__getitem__'):
2293 # Don't autocall in this case: item access for an object
2297 # Don't autocall in this case: item access for an object
2294 # which is BOTH callable and implements __getitem__.
2298 # which is BOTH callable and implements __getitem__.
2295 newcmd = '%s %s' % (iFun,theRest)
2299 newcmd = '%s %s' % (iFun,theRest)
2296 auto_rewrite = False
2300 auto_rewrite = False
2297 else:
2301 else:
2298 # if the object doesn't support [] access, go ahead and
2302 # if the object doesn't support [] access, go ahead and
2299 # autocall
2303 # autocall
2300 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2304 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2301 elif theRest.endswith(';'):
2305 elif theRest.endswith(';'):
2302 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2306 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2303 else:
2307 else:
2304 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2308 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2305
2309
2306 if auto_rewrite:
2310 if auto_rewrite:
2307 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2311 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2308
2312
2309 try:
2313 try:
2310 # plain ascii works better w/ pyreadline, on some machines, so
2314 # plain ascii works better w/ pyreadline, on some machines, so
2311 # we use it and only print uncolored rewrite if we have unicode
2315 # we use it and only print uncolored rewrite if we have unicode
2312 rw = str(rw)
2316 rw = str(rw)
2313 print >>Term.cout, rw
2317 print >>Term.cout, rw
2314 except UnicodeEncodeError:
2318 except UnicodeEncodeError:
2315 print "-------------->" + newcmd
2319 print "-------------->" + newcmd
2316
2320
2317 # log what is now valid Python, not the actual user input (without the
2321 # log what is now valid Python, not the actual user input (without the
2318 # final newline)
2322 # final newline)
2319 self.log(line,newcmd,continue_prompt)
2323 self.log(line,newcmd,continue_prompt)
2320 return newcmd
2324 return newcmd
2321
2325
2322 def handle_help(self, line_info):
2326 def handle_help(self, line_info):
2323 """Try to get some help for the object.
2327 """Try to get some help for the object.
2324
2328
2325 obj? or ?obj -> basic information.
2329 obj? or ?obj -> basic information.
2326 obj?? or ??obj -> more details.
2330 obj?? or ??obj -> more details.
2327 """
2331 """
2328
2332
2329 line = line_info.line
2333 line = line_info.line
2330 # We need to make sure that we don't process lines which would be
2334 # We need to make sure that we don't process lines which would be
2331 # otherwise valid python, such as "x=1 # what?"
2335 # otherwise valid python, such as "x=1 # what?"
2332 try:
2336 try:
2333 codeop.compile_command(line)
2337 codeop.compile_command(line)
2334 except SyntaxError:
2338 except SyntaxError:
2335 # We should only handle as help stuff which is NOT valid syntax
2339 # We should only handle as help stuff which is NOT valid syntax
2336 if line[0]==self.ESC_HELP:
2340 if line[0]==self.ESC_HELP:
2337 line = line[1:]
2341 line = line[1:]
2338 elif line[-1]==self.ESC_HELP:
2342 elif line[-1]==self.ESC_HELP:
2339 line = line[:-1]
2343 line = line[:-1]
2340 self.log(line,'#?'+line,line_info.continue_prompt)
2344 self.log(line,'#?'+line,line_info.continue_prompt)
2341 if line:
2345 if line:
2342 #print 'line:<%r>' % line # dbg
2346 #print 'line:<%r>' % line # dbg
2343 self.magic_pinfo(line)
2347 self.magic_pinfo(line)
2344 else:
2348 else:
2345 page(self.usage,screen_lines=self.rc.screen_length)
2349 page(self.usage,screen_lines=self.rc.screen_length)
2346 return '' # Empty string is needed here!
2350 return '' # Empty string is needed here!
2347 except:
2351 except:
2348 # Pass any other exceptions through to the normal handler
2352 # Pass any other exceptions through to the normal handler
2349 return self.handle_normal(line_info)
2353 return self.handle_normal(line_info)
2350 else:
2354 else:
2351 # If the code compiles ok, we should handle it normally
2355 # If the code compiles ok, we should handle it normally
2352 return self.handle_normal(line_info)
2356 return self.handle_normal(line_info)
2353
2357
2354 def getapi(self):
2358 def getapi(self):
2355 """ Get an IPApi object for this shell instance
2359 """ Get an IPApi object for this shell instance
2356
2360
2357 Getting an IPApi object is always preferable to accessing the shell
2361 Getting an IPApi object is always preferable to accessing the shell
2358 directly, but this holds true especially for extensions.
2362 directly, but this holds true especially for extensions.
2359
2363
2360 It should always be possible to implement an extension with IPApi
2364 It should always be possible to implement an extension with IPApi
2361 alone. If not, contact maintainer to request an addition.
2365 alone. If not, contact maintainer to request an addition.
2362
2366
2363 """
2367 """
2364 return self.api
2368 return self.api
2365
2369
2366 def handle_emacs(self, line_info):
2370 def handle_emacs(self, line_info):
2367 """Handle input lines marked by python-mode."""
2371 """Handle input lines marked by python-mode."""
2368
2372
2369 # Currently, nothing is done. Later more functionality can be added
2373 # Currently, nothing is done. Later more functionality can be added
2370 # here if needed.
2374 # here if needed.
2371
2375
2372 # The input cache shouldn't be updated
2376 # The input cache shouldn't be updated
2373 return line_info.line
2377 return line_info.line
2374
2378
2375
2379
2376 def mktempfile(self,data=None):
2380 def mktempfile(self,data=None):
2377 """Make a new tempfile and return its filename.
2381 """Make a new tempfile and return its filename.
2378
2382
2379 This makes a call to tempfile.mktemp, but it registers the created
2383 This makes a call to tempfile.mktemp, but it registers the created
2380 filename internally so ipython cleans it up at exit time.
2384 filename internally so ipython cleans it up at exit time.
2381
2385
2382 Optional inputs:
2386 Optional inputs:
2383
2387
2384 - data(None): if data is given, it gets written out to the temp file
2388 - data(None): if data is given, it gets written out to the temp file
2385 immediately, and the file is closed again."""
2389 immediately, and the file is closed again."""
2386
2390
2387 filename = tempfile.mktemp('.py','ipython_edit_')
2391 filename = tempfile.mktemp('.py','ipython_edit_')
2388 self.tempfiles.append(filename)
2392 self.tempfiles.append(filename)
2389
2393
2390 if data:
2394 if data:
2391 tmp_file = open(filename,'w')
2395 tmp_file = open(filename,'w')
2392 tmp_file.write(data)
2396 tmp_file.write(data)
2393 tmp_file.close()
2397 tmp_file.close()
2394 return filename
2398 return filename
2395
2399
2396 def write(self,data):
2400 def write(self,data):
2397 """Write a string to the default output"""
2401 """Write a string to the default output"""
2398 Term.cout.write(data)
2402 Term.cout.write(data)
2399
2403
2400 def write_err(self,data):
2404 def write_err(self,data):
2401 """Write a string to the default error output"""
2405 """Write a string to the default error output"""
2402 Term.cerr.write(data)
2406 Term.cerr.write(data)
2403
2407
2404 def exit(self):
2408 def exit(self):
2405 """Handle interactive exit.
2409 """Handle interactive exit.
2406
2410
2407 This method sets the exit_now attribute."""
2411 This method sets the exit_now attribute."""
2408
2412
2409 if self.rc.confirm_exit:
2413 if self.rc.confirm_exit:
2410 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2414 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2411 self.exit_now = True
2415 self.exit_now = True
2412 else:
2416 else:
2413 self.exit_now = True
2417 self.exit_now = True
2414
2418
2415 def safe_execfile(self,fname,*where,**kw):
2419 def safe_execfile(self,fname,*where,**kw):
2416 """A safe version of the builtin execfile().
2420 """A safe version of the builtin execfile().
2417
2421
2418 This version will never throw an exception, and knows how to handle
2422 This version will never throw an exception, and knows how to handle
2419 ipython logs as well.
2423 ipython logs as well.
2420
2424
2421 :Parameters:
2425 :Parameters:
2422 fname : string
2426 fname : string
2423 Name of the file to be executed.
2427 Name of the file to be executed.
2424
2428
2425 where : tuple
2429 where : tuple
2426 One or two namespaces, passed to execfile() as (globals,locals).
2430 One or two namespaces, passed to execfile() as (globals,locals).
2427 If only one is given, it is passed as both.
2431 If only one is given, it is passed as both.
2428
2432
2429 :Keywords:
2433 :Keywords:
2430 islog : boolean (False)
2434 islog : boolean (False)
2431
2435
2432 quiet : boolean (True)
2436 quiet : boolean (True)
2433
2437
2434 exit_ignore : boolean (False)
2438 exit_ignore : boolean (False)
2435 """
2439 """
2436
2440
2437 def syspath_cleanup():
2441 def syspath_cleanup():
2438 """Internal cleanup routine for sys.path."""
2442 """Internal cleanup routine for sys.path."""
2439 if add_dname:
2443 if add_dname:
2440 try:
2444 try:
2441 sys.path.remove(dname)
2445 sys.path.remove(dname)
2442 except ValueError:
2446 except ValueError:
2443 # For some reason the user has already removed it, ignore.
2447 # For some reason the user has already removed it, ignore.
2444 pass
2448 pass
2445
2449
2446 fname = os.path.expanduser(fname)
2450 fname = os.path.expanduser(fname)
2447
2451
2448 # Find things also in current directory. This is needed to mimic the
2452 # Find things also in current directory. This is needed to mimic the
2449 # behavior of running a script from the system command line, where
2453 # behavior of running a script from the system command line, where
2450 # Python inserts the script's directory into sys.path
2454 # Python inserts the script's directory into sys.path
2451 dname = os.path.dirname(os.path.abspath(fname))
2455 dname = os.path.dirname(os.path.abspath(fname))
2452 add_dname = False
2456 add_dname = False
2453 if dname not in sys.path:
2457 if dname not in sys.path:
2454 sys.path.insert(0,dname)
2458 sys.path.insert(0,dname)
2455 add_dname = True
2459 add_dname = True
2456
2460
2457 try:
2461 try:
2458 xfile = open(fname)
2462 xfile = open(fname)
2459 except:
2463 except:
2460 print >> Term.cerr, \
2464 print >> Term.cerr, \
2461 'Could not open file <%s> for safe execution.' % fname
2465 'Could not open file <%s> for safe execution.' % fname
2462 syspath_cleanup()
2466 syspath_cleanup()
2463 return None
2467 return None
2464
2468
2465 kw.setdefault('islog',0)
2469 kw.setdefault('islog',0)
2466 kw.setdefault('quiet',1)
2470 kw.setdefault('quiet',1)
2467 kw.setdefault('exit_ignore',0)
2471 kw.setdefault('exit_ignore',0)
2468
2472
2469 first = xfile.readline()
2473 first = xfile.readline()
2470 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2474 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2471 xfile.close()
2475 xfile.close()
2472 # line by line execution
2476 # line by line execution
2473 if first.startswith(loghead) or kw['islog']:
2477 if first.startswith(loghead) or kw['islog']:
2474 print 'Loading log file <%s> one line at a time...' % fname
2478 print 'Loading log file <%s> one line at a time...' % fname
2475 if kw['quiet']:
2479 if kw['quiet']:
2476 stdout_save = sys.stdout
2480 stdout_save = sys.stdout
2477 sys.stdout = StringIO.StringIO()
2481 sys.stdout = StringIO.StringIO()
2478 try:
2482 try:
2479 globs,locs = where[0:2]
2483 globs,locs = where[0:2]
2480 except:
2484 except:
2481 try:
2485 try:
2482 globs = locs = where[0]
2486 globs = locs = where[0]
2483 except:
2487 except:
2484 globs = locs = globals()
2488 globs = locs = globals()
2485 badblocks = []
2489 badblocks = []
2486
2490
2487 # we also need to identify indented blocks of code when replaying
2491 # we also need to identify indented blocks of code when replaying
2488 # logs and put them together before passing them to an exec
2492 # logs and put them together before passing them to an exec
2489 # statement. This takes a bit of regexp and look-ahead work in the
2493 # statement. This takes a bit of regexp and look-ahead work in the
2490 # file. It's easiest if we swallow the whole thing in memory
2494 # file. It's easiest if we swallow the whole thing in memory
2491 # first, and manually walk through the lines list moving the
2495 # first, and manually walk through the lines list moving the
2492 # counter ourselves.
2496 # counter ourselves.
2493 indent_re = re.compile('\s+\S')
2497 indent_re = re.compile('\s+\S')
2494 xfile = open(fname)
2498 xfile = open(fname)
2495 filelines = xfile.readlines()
2499 filelines = xfile.readlines()
2496 xfile.close()
2500 xfile.close()
2497 nlines = len(filelines)
2501 nlines = len(filelines)
2498 lnum = 0
2502 lnum = 0
2499 while lnum < nlines:
2503 while lnum < nlines:
2500 line = filelines[lnum]
2504 line = filelines[lnum]
2501 lnum += 1
2505 lnum += 1
2502 # don't re-insert logger status info into cache
2506 # don't re-insert logger status info into cache
2503 if line.startswith('#log#'):
2507 if line.startswith('#log#'):
2504 continue
2508 continue
2505 else:
2509 else:
2506 # build a block of code (maybe a single line) for execution
2510 # build a block of code (maybe a single line) for execution
2507 block = line
2511 block = line
2508 try:
2512 try:
2509 next = filelines[lnum] # lnum has already incremented
2513 next = filelines[lnum] # lnum has already incremented
2510 except:
2514 except:
2511 next = None
2515 next = None
2512 while next and indent_re.match(next):
2516 while next and indent_re.match(next):
2513 block += next
2517 block += next
2514 lnum += 1
2518 lnum += 1
2515 try:
2519 try:
2516 next = filelines[lnum]
2520 next = filelines[lnum]
2517 except:
2521 except:
2518 next = None
2522 next = None
2519 # now execute the block of one or more lines
2523 # now execute the block of one or more lines
2520 try:
2524 try:
2521 exec block in globs,locs
2525 exec block in globs,locs
2522 except SystemExit:
2526 except SystemExit:
2523 pass
2527 pass
2524 except:
2528 except:
2525 badblocks.append(block.rstrip())
2529 badblocks.append(block.rstrip())
2526 if kw['quiet']: # restore stdout
2530 if kw['quiet']: # restore stdout
2527 sys.stdout.close()
2531 sys.stdout.close()
2528 sys.stdout = stdout_save
2532 sys.stdout = stdout_save
2529 print 'Finished replaying log file <%s>' % fname
2533 print 'Finished replaying log file <%s>' % fname
2530 if badblocks:
2534 if badblocks:
2531 print >> sys.stderr, ('\nThe following lines/blocks in file '
2535 print >> sys.stderr, ('\nThe following lines/blocks in file '
2532 '<%s> reported errors:' % fname)
2536 '<%s> reported errors:' % fname)
2533
2537
2534 for badline in badblocks:
2538 for badline in badblocks:
2535 print >> sys.stderr, badline
2539 print >> sys.stderr, badline
2536 else: # regular file execution
2540 else: # regular file execution
2537 try:
2541 try:
2538 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2542 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2539 # Work around a bug in Python for Windows. The bug was
2543 # Work around a bug in Python for Windows. The bug was
2540 # fixed in in Python 2.5 r54159 and 54158, but that's still
2544 # fixed in in Python 2.5 r54159 and 54158, but that's still
2541 # SVN Python as of March/07. For details, see:
2545 # SVN Python as of March/07. For details, see:
2542 # http://projects.scipy.org/ipython/ipython/ticket/123
2546 # http://projects.scipy.org/ipython/ipython/ticket/123
2543 try:
2547 try:
2544 globs,locs = where[0:2]
2548 globs,locs = where[0:2]
2545 except:
2549 except:
2546 try:
2550 try:
2547 globs = locs = where[0]
2551 globs = locs = where[0]
2548 except:
2552 except:
2549 globs = locs = globals()
2553 globs = locs = globals()
2550 exec file(fname) in globs,locs
2554 exec file(fname) in globs,locs
2551 else:
2555 else:
2552 execfile(fname,*where)
2556 execfile(fname,*where)
2553 except SyntaxError:
2557 except SyntaxError:
2554 self.showsyntaxerror()
2558 self.showsyntaxerror()
2555 warn('Failure executing file: <%s>' % fname)
2559 warn('Failure executing file: <%s>' % fname)
2556 except SystemExit,status:
2560 except SystemExit,status:
2557 # Code that correctly sets the exit status flag to success (0)
2561 # Code that correctly sets the exit status flag to success (0)
2558 # shouldn't be bothered with a traceback. Note that a plain
2562 # shouldn't be bothered with a traceback. Note that a plain
2559 # sys.exit() does NOT set the message to 0 (it's empty) so that
2563 # sys.exit() does NOT set the message to 0 (it's empty) so that
2560 # will still get a traceback. Note that the structure of the
2564 # will still get a traceback. Note that the structure of the
2561 # SystemExit exception changed between Python 2.4 and 2.5, so
2565 # SystemExit exception changed between Python 2.4 and 2.5, so
2562 # the checks must be done in a version-dependent way.
2566 # the checks must be done in a version-dependent way.
2563 show = False
2567 show = False
2564
2568
2565 if sys.version_info[:2] > (2,5):
2569 if sys.version_info[:2] > (2,5):
2566 if status.message!=0 and not kw['exit_ignore']:
2570 if status.message!=0 and not kw['exit_ignore']:
2567 show = True
2571 show = True
2568 else:
2572 else:
2569 if status.code and not kw['exit_ignore']:
2573 if status.code and not kw['exit_ignore']:
2570 show = True
2574 show = True
2571 if show:
2575 if show:
2572 self.showtraceback()
2576 self.showtraceback()
2573 warn('Failure executing file: <%s>' % fname)
2577 warn('Failure executing file: <%s>' % fname)
2574 except:
2578 except:
2575 self.showtraceback()
2579 self.showtraceback()
2576 warn('Failure executing file: <%s>' % fname)
2580 warn('Failure executing file: <%s>' % fname)
2577
2581
2578 syspath_cleanup()
2582 syspath_cleanup()
2579
2583
2580 #************************* end of file <iplib.py> *****************************
2584 #************************* end of file <iplib.py> *****************************
@@ -1,763 +1,763
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 better.
5 Requires Python 2.1 or better.
6
6
7 This file contains the main make_IPython() starter function.
7 This file contains the main make_IPython() starter function.
8
8
9 $Id: ipmaker.py 2887 2007-12-12 08:28:43Z fperez $"""
9 $Id: ipmaker.py 2899 2007-12-28 08:32:59Z fperez $"""
10
10
11 #*****************************************************************************
11 #*****************************************************************************
12 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
12 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
13 #
13 #
14 # Distributed under the terms of the BSD License. The full license is in
14 # Distributed under the terms of the BSD License. The full license is in
15 # the file COPYING, distributed as part of this software.
15 # the file COPYING, distributed as part of this software.
16 #*****************************************************************************
16 #*****************************************************************************
17
17
18 from IPython import Release
18 from IPython import Release
19 __author__ = '%s <%s>' % Release.authors['Fernando']
19 __author__ = '%s <%s>' % Release.authors['Fernando']
20 __license__ = Release.license
20 __license__ = Release.license
21 __version__ = Release.version
21 __version__ = Release.version
22
22
23 try:
23 try:
24 credits._Printer__data = """
24 credits._Printer__data = """
25 Python: %s
25 Python: %s
26
26
27 IPython: Fernando Perez, Janko Hauser, Nathan Gray, and many users.
27 IPython: Fernando Perez, Janko Hauser, Nathan Gray, and many users.
28 See http://ipython.scipy.org for more information.""" \
28 See http://ipython.scipy.org for more information.""" \
29 % credits._Printer__data
29 % credits._Printer__data
30
30
31 copyright._Printer__data += """
31 copyright._Printer__data += """
32
32
33 Copyright (c) 2001-2004 Fernando Perez, Janko Hauser, Nathan Gray.
33 Copyright (c) 2001-2004 Fernando Perez, Janko Hauser, Nathan Gray.
34 All Rights Reserved."""
34 All Rights Reserved."""
35 except NameError:
35 except NameError:
36 # Can happen if ipython was started with 'python -S', so that site.py is
36 # Can happen if ipython was started with 'python -S', so that site.py is
37 # not loaded
37 # not loaded
38 pass
38 pass
39
39
40 #****************************************************************************
40 #****************************************************************************
41 # Required modules
41 # Required modules
42
42
43 # From the standard library
43 # From the standard library
44 import __main__
44 import __main__
45 import __builtin__
45 import __builtin__
46 import os
46 import os
47 import re
47 import re
48 import sys
48 import sys
49 import types
49 import types
50 from pprint import pprint,pformat
50 from pprint import pprint,pformat
51
51
52 # Our own
52 # Our own
53 from IPython import DPyGetOpt
53 from IPython import DPyGetOpt
54 from IPython.ipstruct import Struct
54 from IPython.ipstruct import Struct
55 from IPython.OutputTrap import OutputTrap
55 from IPython.OutputTrap import OutputTrap
56 from IPython.ConfigLoader import ConfigLoader
56 from IPython.ConfigLoader import ConfigLoader
57 from IPython.iplib import InteractiveShell
57 from IPython.iplib import InteractiveShell
58 from IPython.usage import cmd_line_usage,interactive_usage
58 from IPython.usage import cmd_line_usage,interactive_usage
59 from IPython.genutils import *
59 from IPython.genutils import *
60
60
61 #-----------------------------------------------------------------------------
61 #-----------------------------------------------------------------------------
62 def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,
62 def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,
63 rc_override=None,shell_class=InteractiveShell,
63 rc_override=None,shell_class=InteractiveShell,
64 embedded=False,**kw):
64 embedded=False,**kw):
65 """This is a dump of IPython into a single function.
65 """This is a dump of IPython into a single function.
66
66
67 Later it will have to be broken up in a sensible manner.
67 Later it will have to be broken up in a sensible manner.
68
68
69 Arguments:
69 Arguments:
70
70
71 - argv: a list similar to sys.argv[1:]. It should NOT contain the desired
71 - argv: a list similar to sys.argv[1:]. It should NOT contain the desired
72 script name, b/c DPyGetOpt strips the first argument only for the real
72 script name, b/c DPyGetOpt strips the first argument only for the real
73 sys.argv.
73 sys.argv.
74
74
75 - user_ns: a dict to be used as the user's namespace."""
75 - user_ns: a dict to be used as the user's namespace."""
76
76
77 #----------------------------------------------------------------------
77 #----------------------------------------------------------------------
78 # Defaults and initialization
78 # Defaults and initialization
79
79
80 # For developer debugging, deactivates crash handler and uses pdb.
80 # For developer debugging, deactivates crash handler and uses pdb.
81 DEVDEBUG = False
81 DEVDEBUG = False
82
82
83 if argv is None:
83 if argv is None:
84 argv = sys.argv
84 argv = sys.argv
85
85
86 # __IP is the main global that lives throughout and represents the whole
86 # __IP is the main global that lives throughout and represents the whole
87 # application. If the user redefines it, all bets are off as to what
87 # application. If the user redefines it, all bets are off as to what
88 # happens.
88 # happens.
89
89
90 # __IP is the name of he global which the caller will have accessible as
90 # __IP is the name of he global which the caller will have accessible as
91 # __IP.name. We set its name via the first parameter passed to
91 # __IP.name. We set its name via the first parameter passed to
92 # InteractiveShell:
92 # InteractiveShell:
93
93
94 IP = shell_class('__IP',user_ns=user_ns,user_global_ns=user_global_ns,
94 IP = shell_class('__IP',user_ns=user_ns,user_global_ns=user_global_ns,
95 embedded=embedded,**kw)
95 embedded=embedded,**kw)
96
96
97 # Put 'help' in the user namespace
97 # Put 'help' in the user namespace
98 from site import _Helper
98 from site import _Helper
99 IP.user_config_ns = {}
99 IP.user_config_ns = {}
100 IP.user_ns['help'] = _Helper()
100 IP.user_ns['help'] = _Helper()
101
101
102
102
103 if DEVDEBUG:
103 if DEVDEBUG:
104 # For developer debugging only (global flag)
104 # For developer debugging only (global flag)
105 from IPython import ultraTB
105 from IPython import ultraTB
106 sys.excepthook = ultraTB.VerboseTB(call_pdb=1)
106 sys.excepthook = ultraTB.VerboseTB(call_pdb=1)
107
107
108 IP.BANNER_PARTS = ['Python %s\n'
108 IP.BANNER_PARTS = ['Python %s\n'
109 'Type "copyright", "credits" or "license" '
109 'Type "copyright", "credits" or "license" '
110 'for more information.\n'
110 'for more information.\n'
111 % (sys.version.split('\n')[0],),
111 % (sys.version.split('\n')[0],),
112 "IPython %s -- An enhanced Interactive Python."
112 "IPython %s -- An enhanced Interactive Python."
113 % (__version__,),
113 % (__version__,),
114 """\
114 """\
115 ? -> Introduction and overview of IPython's features.
115 ? -> Introduction and overview of IPython's features.
116 %quickref -> Quick reference.
116 %quickref -> Quick reference.
117 help -> Python's own help system.
117 help -> Python's own help system.
118 object? -> Details about 'object'. ?object also works, ?? prints more.
118 object? -> Details about 'object'. ?object also works, ?? prints more.
119 """ ]
119 """ ]
120
120
121 IP.usage = interactive_usage
121 IP.usage = interactive_usage
122
122
123 # Platform-dependent suffix and directory names. We use _ipython instead
123 # Platform-dependent suffix and directory names. We use _ipython instead
124 # of .ipython under win32 b/c there's software that breaks with .named
124 # of .ipython under win32 b/c there's software that breaks with .named
125 # directories on that platform.
125 # directories on that platform.
126 if os.name == 'posix':
126 if os.name == 'posix':
127 rc_suffix = ''
127 rc_suffix = ''
128 ipdir_def = '.ipython'
128 ipdir_def = '.ipython'
129 else:
129 else:
130 rc_suffix = '.ini'
130 rc_suffix = '.ini'
131 ipdir_def = '_ipython'
131 ipdir_def = '_ipython'
132
132
133 # default directory for configuration
133 # default directory for configuration
134 ipythondir_def = os.path.abspath(os.environ.get('IPYTHONDIR',
134 ipythondir_def = os.path.abspath(os.environ.get('IPYTHONDIR',
135 os.path.join(IP.home_dir,ipdir_def)))
135 os.path.join(IP.home_dir,ipdir_def)))
136
136
137 sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
137 sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
138
138
139 # we need the directory where IPython itself is installed
139 # we need the directory where IPython itself is installed
140 import IPython
140 import IPython
141 IPython_dir = os.path.dirname(IPython.__file__)
141 IPython_dir = os.path.dirname(IPython.__file__)
142 del IPython
142 del IPython
143
143
144 #-------------------------------------------------------------------------
144 #-------------------------------------------------------------------------
145 # Command line handling
145 # Command line handling
146
146
147 # Valid command line options (uses DPyGetOpt syntax, like Perl's
147 # Valid command line options (uses DPyGetOpt syntax, like Perl's
148 # GetOpt::Long)
148 # GetOpt::Long)
149
149
150 # Any key not listed here gets deleted even if in the file (like session
150 # Any key not listed here gets deleted even if in the file (like session
151 # or profile). That's deliberate, to maintain the rc namespace clean.
151 # or profile). That's deliberate, to maintain the rc namespace clean.
152
152
153 # Each set of options appears twice: under _conv only the names are
153 # Each set of options appears twice: under _conv only the names are
154 # listed, indicating which type they must be converted to when reading the
154 # listed, indicating which type they must be converted to when reading the
155 # ipythonrc file. And under DPyGetOpt they are listed with the regular
155 # ipythonrc file. And under DPyGetOpt they are listed with the regular
156 # DPyGetOpt syntax (=s,=i,:f,etc).
156 # DPyGetOpt syntax (=s,=i,:f,etc).
157
157
158 # Make sure there's a space before each end of line (they get auto-joined!)
158 # Make sure there's a space before each end of line (they get auto-joined!)
159 cmdline_opts = ('autocall=i autoindent! automagic! banner! cache_size|cs=i '
159 cmdline_opts = ('autocall=i autoindent! automagic! banner! cache_size|cs=i '
160 'c=s classic|cl color_info! colors=s confirm_exit! '
160 'c=s classic|cl color_info! colors=s confirm_exit! '
161 'debug! deep_reload! editor=s log|l messages! nosep '
161 'debug! deep_reload! editor=s log|l messages! nosep '
162 'object_info_string_level=i pdb! '
162 'object_info_string_level=i pdb! '
163 'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s '
163 'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s '
164 'pylab_import_all! '
164 'pylab_import_all! '
165 'quick screen_length|sl=i prompts_pad_left=i '
165 'quick screen_length|sl=i prompts_pad_left=i '
166 'logfile|lf=s logplay|lp=s profile|p=s '
166 'logfile|lf=s logplay|lp=s profile|p=s '
167 'readline! readline_merge_completions! '
167 'readline! readline_merge_completions! '
168 'readline_omit__names! '
168 'readline_omit__names! '
169 'rcfile=s separate_in|si=s separate_out|so=s '
169 'rcfile=s separate_in|si=s separate_out|so=s '
170 'separate_out2|so2=s xmode=s wildcards_case_sensitive! '
170 'separate_out2|so2=s xmode=s wildcards_case_sensitive! '
171 'magic_docstrings system_verbose! '
171 'magic_docstrings system_verbose! '
172 'multi_line_specials! '
172 'multi_line_specials! '
173 'term_title! wxversion=s '
173 'term_title! wxversion=s '
174 'autoedit_syntax!')
174 'autoedit_syntax!')
175
175
176 # Options that can *only* appear at the cmd line (not in rcfiles).
176 # Options that can *only* appear at the cmd line (not in rcfiles).
177
177
178 # The "ignore" option is a kludge so that Emacs buffers don't crash, since
178 # The "ignore" option is a kludge so that Emacs buffers don't crash, since
179 # the 'C-c !' command in emacs automatically appends a -i option at the end.
179 # the 'C-c !' command in emacs automatically appends a -i option at the end.
180 cmdline_only = ('help interact|i ipythondir=s Version upgrade '
180 cmdline_only = ('help interact|i ipythondir=s Version upgrade '
181 'gthread! qthread! q4thread! wthread! tkthread! pylab! tk!')
181 'gthread! qthread! q4thread! wthread! tkthread! pylab! tk!')
182
182
183 # Build the actual name list to be used by DPyGetOpt
183 # Build the actual name list to be used by DPyGetOpt
184 opts_names = qw(cmdline_opts) + qw(cmdline_only)
184 opts_names = qw(cmdline_opts) + qw(cmdline_only)
185
185
186 # Set sensible command line defaults.
186 # Set sensible command line defaults.
187 # This should have everything from cmdline_opts and cmdline_only
187 # This should have everything from cmdline_opts and cmdline_only
188 opts_def = Struct(autocall = 1,
188 opts_def = Struct(autocall = 1,
189 autoedit_syntax = 0,
189 autoedit_syntax = 0,
190 autoindent = 0,
190 autoindent = 0,
191 automagic = 1,
191 automagic = 1,
192 banner = 1,
192 banner = 1,
193 cache_size = 1000,
194 c = '',
193 c = '',
194 cache_size = 1000,
195 classic = 0,
195 classic = 0,
196 colors = 'NoColor',
197 color_info = 0,
196 color_info = 0,
197 colors = 'NoColor',
198 confirm_exit = 1,
198 confirm_exit = 1,
199 debug = 0,
199 debug = 0,
200 deep_reload = 0,
200 deep_reload = 0,
201 editor = '0',
201 editor = '0',
202 gthread = 0,
202 help = 0,
203 help = 0,
203 interact = 1,
204 interact = 1,
204 ipythondir = ipythondir_def,
205 ipythondir = ipythondir_def,
205 log = 0,
206 log = 0,
206 logfile = '',
207 logfile = '',
207 logplay = '',
208 logplay = '',
208 multi_line_specials = 1,
209 messages = 1,
209 messages = 1,
210 object_info_string_level = 0,
210 multi_line_specials = 1,
211 nosep = 0,
211 nosep = 0,
212 object_info_string_level = 0,
212 pdb = 0,
213 pdb = 0,
213 pprint = 0,
214 pprint = 0,
214 profile = '',
215 profile = '',
215 prompt_in1 = 'In [\\#]: ',
216 prompt_in1 = 'In [\\#]: ',
216 prompt_in2 = ' .\\D.: ',
217 prompt_in2 = ' .\\D.: ',
217 prompt_out = 'Out[\\#]: ',
218 prompt_out = 'Out[\\#]: ',
218 prompts_pad_left = 1,
219 prompts_pad_left = 1,
220 pylab = 0,
219 pylab_import_all = 1,
221 pylab_import_all = 1,
220 quiet = 0,
222 q4thread = 0,
223 qthread = 0,
221 quick = 0,
224 quick = 0,
225 quiet = 0,
226 rcfile = 'ipythonrc' + rc_suffix,
222 readline = 1,
227 readline = 1,
223 readline_merge_completions = 1,
228 readline_merge_completions = 1,
224 readline_omit__names = 0,
229 readline_omit__names = 0,
225 rcfile = 'ipythonrc' + rc_suffix,
226 screen_length = 0,
230 screen_length = 0,
227 separate_in = '\n',
231 separate_in = '\n',
228 separate_out = '\n',
232 separate_out = '\n',
229 separate_out2 = '',
233 separate_out2 = '',
230 system_header = 'IPython system call: ',
234 system_header = 'IPython system call: ',
231 system_verbose = 0,
235 system_verbose = 0,
232 gthread = 0,
233 qthread = 0,
234 q4thread = 0,
235 wthread = 0,
236 pylab = 0,
237 term_title = 1,
236 term_title = 1,
238 tk = 0,
237 tk = 0,
239 upgrade = 0,
238 upgrade = 0,
240 Version = 0,
239 Version = 0,
241 xmode = 'Verbose',
242 wildcards_case_sensitive = 1,
240 wildcards_case_sensitive = 1,
241 wthread = 0,
243 wxversion = '0',
242 wxversion = '0',
243 xmode = 'Context',
244 magic_docstrings = 0, # undocumented, for doc generation
244 magic_docstrings = 0, # undocumented, for doc generation
245 )
245 )
246
246
247 # Things that will *only* appear in rcfiles (not at the command line).
247 # Things that will *only* appear in rcfiles (not at the command line).
248 # Make sure there's a space before each end of line (they get auto-joined!)
248 # Make sure there's a space before each end of line (they get auto-joined!)
249 rcfile_opts = { qwflat: 'include import_mod import_all execfile ',
249 rcfile_opts = { qwflat: 'include import_mod import_all execfile ',
250 qw_lol: 'import_some ',
250 qw_lol: 'import_some ',
251 # for things with embedded whitespace:
251 # for things with embedded whitespace:
252 list_strings:'execute alias readline_parse_and_bind ',
252 list_strings:'execute alias readline_parse_and_bind ',
253 # Regular strings need no conversion:
253 # Regular strings need no conversion:
254 None:'readline_remove_delims ',
254 None:'readline_remove_delims ',
255 }
255 }
256 # Default values for these
256 # Default values for these
257 rc_def = Struct(include = [],
257 rc_def = Struct(include = [],
258 import_mod = [],
258 import_mod = [],
259 import_all = [],
259 import_all = [],
260 import_some = [[]],
260 import_some = [[]],
261 execute = [],
261 execute = [],
262 execfile = [],
262 execfile = [],
263 alias = [],
263 alias = [],
264 readline_parse_and_bind = [],
264 readline_parse_and_bind = [],
265 readline_remove_delims = '',
265 readline_remove_delims = '',
266 )
266 )
267
267
268 # Build the type conversion dictionary from the above tables:
268 # Build the type conversion dictionary from the above tables:
269 typeconv = rcfile_opts.copy()
269 typeconv = rcfile_opts.copy()
270 typeconv.update(optstr2types(cmdline_opts))
270 typeconv.update(optstr2types(cmdline_opts))
271
271
272 # FIXME: the None key appears in both, put that back together by hand. Ugly!
272 # FIXME: the None key appears in both, put that back together by hand. Ugly!
273 typeconv[None] += ' ' + rcfile_opts[None]
273 typeconv[None] += ' ' + rcfile_opts[None]
274
274
275 # Remove quotes at ends of all strings (used to protect spaces)
275 # Remove quotes at ends of all strings (used to protect spaces)
276 typeconv[unquote_ends] = typeconv[None]
276 typeconv[unquote_ends] = typeconv[None]
277 del typeconv[None]
277 del typeconv[None]
278
278
279 # Build the list we'll use to make all config decisions with defaults:
279 # Build the list we'll use to make all config decisions with defaults:
280 opts_all = opts_def.copy()
280 opts_all = opts_def.copy()
281 opts_all.update(rc_def)
281 opts_all.update(rc_def)
282
282
283 # Build conflict resolver for recursive loading of config files:
283 # Build conflict resolver for recursive loading of config files:
284 # - preserve means the outermost file maintains the value, it is not
284 # - preserve means the outermost file maintains the value, it is not
285 # overwritten if an included file has the same key.
285 # overwritten if an included file has the same key.
286 # - add_flip applies + to the two values, so it better make sense to add
286 # - add_flip applies + to the two values, so it better make sense to add
287 # those types of keys. But it flips them first so that things loaded
287 # those types of keys. But it flips them first so that things loaded
288 # deeper in the inclusion chain have lower precedence.
288 # deeper in the inclusion chain have lower precedence.
289 conflict = {'preserve': ' '.join([ typeconv[int],
289 conflict = {'preserve': ' '.join([ typeconv[int],
290 typeconv[unquote_ends] ]),
290 typeconv[unquote_ends] ]),
291 'add_flip': ' '.join([ typeconv[qwflat],
291 'add_flip': ' '.join([ typeconv[qwflat],
292 typeconv[qw_lol],
292 typeconv[qw_lol],
293 typeconv[list_strings] ])
293 typeconv[list_strings] ])
294 }
294 }
295
295
296 # Now actually process the command line
296 # Now actually process the command line
297 getopt = DPyGetOpt.DPyGetOpt()
297 getopt = DPyGetOpt.DPyGetOpt()
298 getopt.setIgnoreCase(0)
298 getopt.setIgnoreCase(0)
299
299
300 getopt.parseConfiguration(opts_names)
300 getopt.parseConfiguration(opts_names)
301
301
302 try:
302 try:
303 getopt.processArguments(argv)
303 getopt.processArguments(argv)
304 except DPyGetOpt.ArgumentError, exc:
304 except DPyGetOpt.ArgumentError, exc:
305 print cmd_line_usage
305 print cmd_line_usage
306 warn('\nError in Arguments: "%s"' % exc)
306 warn('\nError in Arguments: "%s"' % exc)
307 sys.exit(1)
307 sys.exit(1)
308
308
309 # convert the options dict to a struct for much lighter syntax later
309 # convert the options dict to a struct for much lighter syntax later
310 opts = Struct(getopt.optionValues)
310 opts = Struct(getopt.optionValues)
311 args = getopt.freeValues
311 args = getopt.freeValues
312
312
313 # this is the struct (which has default values at this point) with which
313 # this is the struct (which has default values at this point) with which
314 # we make all decisions:
314 # we make all decisions:
315 opts_all.update(opts)
315 opts_all.update(opts)
316
316
317 # Options that force an immediate exit
317 # Options that force an immediate exit
318 if opts_all.help:
318 if opts_all.help:
319 page(cmd_line_usage)
319 page(cmd_line_usage)
320 sys.exit()
320 sys.exit()
321
321
322 if opts_all.Version:
322 if opts_all.Version:
323 print __version__
323 print __version__
324 sys.exit()
324 sys.exit()
325
325
326 if opts_all.magic_docstrings:
326 if opts_all.magic_docstrings:
327 IP.magic_magic('-latex')
327 IP.magic_magic('-latex')
328 sys.exit()
328 sys.exit()
329
329
330 # add personal ipythondir to sys.path so that users can put things in
330 # add personal ipythondir to sys.path so that users can put things in
331 # there for customization
331 # there for customization
332 sys.path.append(os.path.abspath(opts_all.ipythondir))
332 sys.path.append(os.path.abspath(opts_all.ipythondir))
333
333
334 # Create user config directory if it doesn't exist. This must be done
334 # Create user config directory if it doesn't exist. This must be done
335 # *after* getting the cmd line options.
335 # *after* getting the cmd line options.
336 if not os.path.isdir(opts_all.ipythondir):
336 if not os.path.isdir(opts_all.ipythondir):
337 IP.user_setup(opts_all.ipythondir,rc_suffix,'install')
337 IP.user_setup(opts_all.ipythondir,rc_suffix,'install')
338
338
339 # upgrade user config files while preserving a copy of the originals
339 # upgrade user config files while preserving a copy of the originals
340 if opts_all.upgrade:
340 if opts_all.upgrade:
341 IP.user_setup(opts_all.ipythondir,rc_suffix,'upgrade')
341 IP.user_setup(opts_all.ipythondir,rc_suffix,'upgrade')
342
342
343 # check mutually exclusive options in the *original* command line
343 # check mutually exclusive options in the *original* command line
344 mutex_opts(opts,[qw('log logfile'),qw('rcfile profile'),
344 mutex_opts(opts,[qw('log logfile'),qw('rcfile profile'),
345 qw('classic profile'),qw('classic rcfile')])
345 qw('classic profile'),qw('classic rcfile')])
346
346
347 #---------------------------------------------------------------------------
347 #---------------------------------------------------------------------------
348 # Log replay
348 # Log replay
349
349
350 # if -logplay, we need to 'become' the other session. That basically means
350 # if -logplay, we need to 'become' the other session. That basically means
351 # replacing the current command line environment with that of the old
351 # replacing the current command line environment with that of the old
352 # session and moving on.
352 # session and moving on.
353
353
354 # this is needed so that later we know we're in session reload mode, as
354 # this is needed so that later we know we're in session reload mode, as
355 # opts_all will get overwritten:
355 # opts_all will get overwritten:
356 load_logplay = 0
356 load_logplay = 0
357
357
358 if opts_all.logplay:
358 if opts_all.logplay:
359 load_logplay = opts_all.logplay
359 load_logplay = opts_all.logplay
360 opts_debug_save = opts_all.debug
360 opts_debug_save = opts_all.debug
361 try:
361 try:
362 logplay = open(opts_all.logplay)
362 logplay = open(opts_all.logplay)
363 except IOError:
363 except IOError:
364 if opts_all.debug: IP.InteractiveTB()
364 if opts_all.debug: IP.InteractiveTB()
365 warn('Could not open logplay file '+`opts_all.logplay`)
365 warn('Could not open logplay file '+`opts_all.logplay`)
366 # restore state as if nothing had happened and move on, but make
366 # restore state as if nothing had happened and move on, but make
367 # sure that later we don't try to actually load the session file
367 # sure that later we don't try to actually load the session file
368 logplay = None
368 logplay = None
369 load_logplay = 0
369 load_logplay = 0
370 del opts_all.logplay
370 del opts_all.logplay
371 else:
371 else:
372 try:
372 try:
373 logplay.readline()
373 logplay.readline()
374 logplay.readline();
374 logplay.readline();
375 # this reloads that session's command line
375 # this reloads that session's command line
376 cmd = logplay.readline()[6:]
376 cmd = logplay.readline()[6:]
377 exec cmd
377 exec cmd
378 # restore the true debug flag given so that the process of
378 # restore the true debug flag given so that the process of
379 # session loading itself can be monitored.
379 # session loading itself can be monitored.
380 opts.debug = opts_debug_save
380 opts.debug = opts_debug_save
381 # save the logplay flag so later we don't overwrite the log
381 # save the logplay flag so later we don't overwrite the log
382 opts.logplay = load_logplay
382 opts.logplay = load_logplay
383 # now we must update our own structure with defaults
383 # now we must update our own structure with defaults
384 opts_all.update(opts)
384 opts_all.update(opts)
385 # now load args
385 # now load args
386 cmd = logplay.readline()[6:]
386 cmd = logplay.readline()[6:]
387 exec cmd
387 exec cmd
388 logplay.close()
388 logplay.close()
389 except:
389 except:
390 logplay.close()
390 logplay.close()
391 if opts_all.debug: IP.InteractiveTB()
391 if opts_all.debug: IP.InteractiveTB()
392 warn("Logplay file lacking full configuration information.\n"
392 warn("Logplay file lacking full configuration information.\n"
393 "I'll try to read it, but some things may not work.")
393 "I'll try to read it, but some things may not work.")
394
394
395 #-------------------------------------------------------------------------
395 #-------------------------------------------------------------------------
396 # set up output traps: catch all output from files, being run, modules
396 # set up output traps: catch all output from files, being run, modules
397 # loaded, etc. Then give it to the user in a clean form at the end.
397 # loaded, etc. Then give it to the user in a clean form at the end.
398
398
399 msg_out = 'Output messages. '
399 msg_out = 'Output messages. '
400 msg_err = 'Error messages. '
400 msg_err = 'Error messages. '
401 msg_sep = '\n'
401 msg_sep = '\n'
402 msg = Struct(config = OutputTrap('Configuration Loader',msg_out,
402 msg = Struct(config = OutputTrap('Configuration Loader',msg_out,
403 msg_err,msg_sep,debug,
403 msg_err,msg_sep,debug,
404 quiet_out=1),
404 quiet_out=1),
405 user_exec = OutputTrap('User File Execution',msg_out,
405 user_exec = OutputTrap('User File Execution',msg_out,
406 msg_err,msg_sep,debug),
406 msg_err,msg_sep,debug),
407 logplay = OutputTrap('Log Loader',msg_out,
407 logplay = OutputTrap('Log Loader',msg_out,
408 msg_err,msg_sep,debug),
408 msg_err,msg_sep,debug),
409 summary = ''
409 summary = ''
410 )
410 )
411
411
412 #-------------------------------------------------------------------------
412 #-------------------------------------------------------------------------
413 # Process user ipythonrc-type configuration files
413 # Process user ipythonrc-type configuration files
414
414
415 # turn on output trapping and log to msg.config
415 # turn on output trapping and log to msg.config
416 # remember that with debug on, trapping is actually disabled
416 # remember that with debug on, trapping is actually disabled
417 msg.config.trap_all()
417 msg.config.trap_all()
418
418
419 # look for rcfile in current or default directory
419 # look for rcfile in current or default directory
420 try:
420 try:
421 opts_all.rcfile = filefind(opts_all.rcfile,opts_all.ipythondir)
421 opts_all.rcfile = filefind(opts_all.rcfile,opts_all.ipythondir)
422 except IOError:
422 except IOError:
423 if opts_all.debug: IP.InteractiveTB()
423 if opts_all.debug: IP.InteractiveTB()
424 warn('Configuration file %s not found. Ignoring request.'
424 warn('Configuration file %s not found. Ignoring request.'
425 % (opts_all.rcfile) )
425 % (opts_all.rcfile) )
426
426
427 # 'profiles' are a shorthand notation for config filenames
427 # 'profiles' are a shorthand notation for config filenames
428 profile_handled_by_legacy = False
428 profile_handled_by_legacy = False
429 if opts_all.profile:
429 if opts_all.profile:
430
430
431 try:
431 try:
432 opts_all.rcfile = filefind('ipythonrc-' + opts_all.profile
432 opts_all.rcfile = filefind('ipythonrc-' + opts_all.profile
433 + rc_suffix,
433 + rc_suffix,
434 opts_all.ipythondir)
434 opts_all.ipythondir)
435 profile_handled_by_legacy = True
435 profile_handled_by_legacy = True
436 except IOError:
436 except IOError:
437 if opts_all.debug: IP.InteractiveTB()
437 if opts_all.debug: IP.InteractiveTB()
438 opts.profile = '' # remove profile from options if invalid
438 opts.profile = '' # remove profile from options if invalid
439 # We won't warn anymore, primary method is ipy_profile_PROFNAME
439 # We won't warn anymore, primary method is ipy_profile_PROFNAME
440 # which does trigger a warning.
440 # which does trigger a warning.
441
441
442 # load the config file
442 # load the config file
443 rcfiledata = None
443 rcfiledata = None
444 if opts_all.quick:
444 if opts_all.quick:
445 print 'Launching IPython in quick mode. No config file read.'
445 print 'Launching IPython in quick mode. No config file read.'
446 elif opts_all.rcfile:
446 elif opts_all.rcfile:
447 try:
447 try:
448 cfg_loader = ConfigLoader(conflict)
448 cfg_loader = ConfigLoader(conflict)
449 rcfiledata = cfg_loader.load(opts_all.rcfile,typeconv,
449 rcfiledata = cfg_loader.load(opts_all.rcfile,typeconv,
450 'include',opts_all.ipythondir,
450 'include',opts_all.ipythondir,
451 purge = 1,
451 purge = 1,
452 unique = conflict['preserve'])
452 unique = conflict['preserve'])
453 except:
453 except:
454 IP.InteractiveTB()
454 IP.InteractiveTB()
455 warn('Problems loading configuration file '+
455 warn('Problems loading configuration file '+
456 `opts_all.rcfile`+
456 `opts_all.rcfile`+
457 '\nStarting with default -bare bones- configuration.')
457 '\nStarting with default -bare bones- configuration.')
458 else:
458 else:
459 warn('No valid configuration file found in either currrent directory\n'+
459 warn('No valid configuration file found in either currrent directory\n'+
460 'or in the IPython config. directory: '+`opts_all.ipythondir`+
460 'or in the IPython config. directory: '+`opts_all.ipythondir`+
461 '\nProceeding with internal defaults.')
461 '\nProceeding with internal defaults.')
462
462
463 #------------------------------------------------------------------------
463 #------------------------------------------------------------------------
464 # Set exception handlers in mode requested by user.
464 # Set exception handlers in mode requested by user.
465 otrap = OutputTrap(trap_out=1) # trap messages from magic_xmode
465 otrap = OutputTrap(trap_out=1) # trap messages from magic_xmode
466 IP.magic_xmode(opts_all.xmode)
466 IP.magic_xmode(opts_all.xmode)
467 otrap.release_out()
467 otrap.release_out()
468
468
469 #------------------------------------------------------------------------
469 #------------------------------------------------------------------------
470 # Execute user config
470 # Execute user config
471
471
472 # Create a valid config structure with the right precedence order:
472 # Create a valid config structure with the right precedence order:
473 # defaults < rcfile < command line. This needs to be in the instance, so
473 # defaults < rcfile < command line. This needs to be in the instance, so
474 # that method calls below that rely on it find it.
474 # that method calls below that rely on it find it.
475 IP.rc = rc_def.copy()
475 IP.rc = rc_def.copy()
476
476
477 # Work with a local alias inside this routine to avoid unnecessary
477 # Work with a local alias inside this routine to avoid unnecessary
478 # attribute lookups.
478 # attribute lookups.
479 IP_rc = IP.rc
479 IP_rc = IP.rc
480
480
481 IP_rc.update(opts_def)
481 IP_rc.update(opts_def)
482 if rcfiledata:
482 if rcfiledata:
483 # now we can update
483 # now we can update
484 IP_rc.update(rcfiledata)
484 IP_rc.update(rcfiledata)
485 IP_rc.update(opts)
485 IP_rc.update(opts)
486 IP_rc.update(rc_override)
486 IP_rc.update(rc_override)
487
487
488 # Store the original cmd line for reference:
488 # Store the original cmd line for reference:
489 IP_rc.opts = opts
489 IP_rc.opts = opts
490 IP_rc.args = args
490 IP_rc.args = args
491
491
492 # create a *runtime* Struct like rc for holding parameters which may be
492 # create a *runtime* Struct like rc for holding parameters which may be
493 # created and/or modified by runtime user extensions.
493 # created and/or modified by runtime user extensions.
494 IP.runtime_rc = Struct()
494 IP.runtime_rc = Struct()
495
495
496 # from this point on, all config should be handled through IP_rc,
496 # from this point on, all config should be handled through IP_rc,
497 # opts* shouldn't be used anymore.
497 # opts* shouldn't be used anymore.
498
498
499
499
500 # update IP_rc with some special things that need manual
500 # update IP_rc with some special things that need manual
501 # tweaks. Basically options which affect other options. I guess this
501 # tweaks. Basically options which affect other options. I guess this
502 # should just be written so that options are fully orthogonal and we
502 # should just be written so that options are fully orthogonal and we
503 # wouldn't worry about this stuff!
503 # wouldn't worry about this stuff!
504
504
505 if IP_rc.classic:
505 if IP_rc.classic:
506 IP_rc.quick = 1
506 IP_rc.quick = 1
507 IP_rc.cache_size = 0
507 IP_rc.cache_size = 0
508 IP_rc.pprint = 0
508 IP_rc.pprint = 0
509 IP_rc.prompt_in1 = '>>> '
509 IP_rc.prompt_in1 = '>>> '
510 IP_rc.prompt_in2 = '... '
510 IP_rc.prompt_in2 = '... '
511 IP_rc.prompt_out = ''
511 IP_rc.prompt_out = ''
512 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
512 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
513 IP_rc.colors = 'NoColor'
513 IP_rc.colors = 'NoColor'
514 IP_rc.xmode = 'Plain'
514 IP_rc.xmode = 'Plain'
515
515
516 IP.pre_config_initialization()
516 IP.pre_config_initialization()
517 # configure readline
517 # configure readline
518 # Define the history file for saving commands in between sessions
518 # Define the history file for saving commands in between sessions
519 if IP_rc.profile:
519 if IP_rc.profile:
520 histfname = 'history-%s' % IP_rc.profile
520 histfname = 'history-%s' % IP_rc.profile
521 else:
521 else:
522 histfname = 'history'
522 histfname = 'history'
523 IP.histfile = os.path.join(opts_all.ipythondir,histfname)
523 IP.histfile = os.path.join(opts_all.ipythondir,histfname)
524
524
525 # update exception handlers with rc file status
525 # update exception handlers with rc file status
526 otrap.trap_out() # I don't want these messages ever.
526 otrap.trap_out() # I don't want these messages ever.
527 IP.magic_xmode(IP_rc.xmode)
527 IP.magic_xmode(IP_rc.xmode)
528 otrap.release_out()
528 otrap.release_out()
529
529
530 # activate logging if requested and not reloading a log
530 # activate logging if requested and not reloading a log
531 if IP_rc.logplay:
531 if IP_rc.logplay:
532 IP.magic_logstart(IP_rc.logplay + ' append')
532 IP.magic_logstart(IP_rc.logplay + ' append')
533 elif IP_rc.logfile:
533 elif IP_rc.logfile:
534 IP.magic_logstart(IP_rc.logfile)
534 IP.magic_logstart(IP_rc.logfile)
535 elif IP_rc.log:
535 elif IP_rc.log:
536 IP.magic_logstart()
536 IP.magic_logstart()
537
537
538 # find user editor so that it we don't have to look it up constantly
538 # find user editor so that it we don't have to look it up constantly
539 if IP_rc.editor.strip()=='0':
539 if IP_rc.editor.strip()=='0':
540 try:
540 try:
541 ed = os.environ['EDITOR']
541 ed = os.environ['EDITOR']
542 except KeyError:
542 except KeyError:
543 if os.name == 'posix':
543 if os.name == 'posix':
544 ed = 'vi' # the only one guaranteed to be there!
544 ed = 'vi' # the only one guaranteed to be there!
545 else:
545 else:
546 ed = 'notepad' # same in Windows!
546 ed = 'notepad' # same in Windows!
547 IP_rc.editor = ed
547 IP_rc.editor = ed
548
548
549 # Keep track of whether this is an embedded instance or not (useful for
549 # Keep track of whether this is an embedded instance or not (useful for
550 # post-mortems).
550 # post-mortems).
551 IP_rc.embedded = IP.embedded
551 IP_rc.embedded = IP.embedded
552
552
553 # Recursive reload
553 # Recursive reload
554 try:
554 try:
555 from IPython import deep_reload
555 from IPython import deep_reload
556 if IP_rc.deep_reload:
556 if IP_rc.deep_reload:
557 __builtin__.reload = deep_reload.reload
557 __builtin__.reload = deep_reload.reload
558 else:
558 else:
559 __builtin__.dreload = deep_reload.reload
559 __builtin__.dreload = deep_reload.reload
560 del deep_reload
560 del deep_reload
561 except ImportError:
561 except ImportError:
562 pass
562 pass
563
563
564 # Save the current state of our namespace so that the interactive shell
564 # Save the current state of our namespace so that the interactive shell
565 # can later know which variables have been created by us from config files
565 # can later know which variables have been created by us from config files
566 # and loading. This way, loading a file (in any way) is treated just like
566 # and loading. This way, loading a file (in any way) is treated just like
567 # defining things on the command line, and %who works as expected.
567 # defining things on the command line, and %who works as expected.
568
568
569 # DON'T do anything that affects the namespace beyond this point!
569 # DON'T do anything that affects the namespace beyond this point!
570 IP.internal_ns.update(__main__.__dict__)
570 IP.internal_ns.update(__main__.__dict__)
571
571
572 #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who
572 #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who
573
573
574 # Now run through the different sections of the users's config
574 # Now run through the different sections of the users's config
575 if IP_rc.debug:
575 if IP_rc.debug:
576 print 'Trying to execute the following configuration structure:'
576 print 'Trying to execute the following configuration structure:'
577 print '(Things listed first are deeper in the inclusion tree and get'
577 print '(Things listed first are deeper in the inclusion tree and get'
578 print 'loaded first).\n'
578 print 'loaded first).\n'
579 pprint(IP_rc.__dict__)
579 pprint(IP_rc.__dict__)
580
580
581 for mod in IP_rc.import_mod:
581 for mod in IP_rc.import_mod:
582 try:
582 try:
583 exec 'import '+mod in IP.user_ns
583 exec 'import '+mod in IP.user_ns
584 except :
584 except :
585 IP.InteractiveTB()
585 IP.InteractiveTB()
586 import_fail_info(mod)
586 import_fail_info(mod)
587
587
588 for mod_fn in IP_rc.import_some:
588 for mod_fn in IP_rc.import_some:
589 if not mod_fn == []:
589 if not mod_fn == []:
590 mod,fn = mod_fn[0],','.join(mod_fn[1:])
590 mod,fn = mod_fn[0],','.join(mod_fn[1:])
591 try:
591 try:
592 exec 'from '+mod+' import '+fn in IP.user_ns
592 exec 'from '+mod+' import '+fn in IP.user_ns
593 except :
593 except :
594 IP.InteractiveTB()
594 IP.InteractiveTB()
595 import_fail_info(mod,fn)
595 import_fail_info(mod,fn)
596
596
597 for mod in IP_rc.import_all:
597 for mod in IP_rc.import_all:
598 try:
598 try:
599 exec 'from '+mod+' import *' in IP.user_ns
599 exec 'from '+mod+' import *' in IP.user_ns
600 except :
600 except :
601 IP.InteractiveTB()
601 IP.InteractiveTB()
602 import_fail_info(mod)
602 import_fail_info(mod)
603
603
604 for code in IP_rc.execute:
604 for code in IP_rc.execute:
605 try:
605 try:
606 exec code in IP.user_ns
606 exec code in IP.user_ns
607 except:
607 except:
608 IP.InteractiveTB()
608 IP.InteractiveTB()
609 warn('Failure executing code: ' + `code`)
609 warn('Failure executing code: ' + `code`)
610
610
611 # Execute the files the user wants in ipythonrc
611 # Execute the files the user wants in ipythonrc
612 for file in IP_rc.execfile:
612 for file in IP_rc.execfile:
613 try:
613 try:
614 file = filefind(file,sys.path+[IPython_dir])
614 file = filefind(file,sys.path+[IPython_dir])
615 except IOError:
615 except IOError:
616 warn(itpl('File $file not found. Skipping it.'))
616 warn(itpl('File $file not found. Skipping it.'))
617 else:
617 else:
618 IP.safe_execfile(os.path.expanduser(file),IP.user_ns)
618 IP.safe_execfile(os.path.expanduser(file),IP.user_ns)
619
619
620 # finally, try importing ipy_*_conf for final configuration
620 # finally, try importing ipy_*_conf for final configuration
621 try:
621 try:
622 import ipy_system_conf
622 import ipy_system_conf
623 except ImportError:
623 except ImportError:
624 if opts_all.debug: IP.InteractiveTB()
624 if opts_all.debug: IP.InteractiveTB()
625 warn("Could not import 'ipy_system_conf'")
625 warn("Could not import 'ipy_system_conf'")
626 except:
626 except:
627 IP.InteractiveTB()
627 IP.InteractiveTB()
628 import_fail_info('ipy_system_conf')
628 import_fail_info('ipy_system_conf')
629
629
630 # only import prof module if ipythonrc-PROF was not found
630 # only import prof module if ipythonrc-PROF was not found
631 if opts_all.profile and not profile_handled_by_legacy:
631 if opts_all.profile and not profile_handled_by_legacy:
632 profmodname = 'ipy_profile_' + opts_all.profile
632 profmodname = 'ipy_profile_' + opts_all.profile
633 try:
633 try:
634 __import__(profmodname)
634 __import__(profmodname)
635 except:
635 except:
636 IP.InteractiveTB()
636 IP.InteractiveTB()
637 print "Error importing",profmodname,"- perhaps you should run %upgrade?"
637 print "Error importing",profmodname,"- perhaps you should run %upgrade?"
638 import_fail_info(profmodname)
638 import_fail_info(profmodname)
639 else:
639 else:
640 import ipy_profile_none
640 import ipy_profile_none
641 try:
641 try:
642 import ipy_user_conf
642 import ipy_user_conf
643
643
644 except:
644 except:
645 conf = opts_all.ipythondir + "/ipy_user_conf.py"
645 conf = opts_all.ipythondir + "/ipy_user_conf.py"
646 IP.InteractiveTB()
646 IP.InteractiveTB()
647 if not os.path.isfile(conf):
647 if not os.path.isfile(conf):
648 warn(conf + ' does not exist, please run %upgrade!')
648 warn(conf + ' does not exist, please run %upgrade!')
649
649
650 import_fail_info("ipy_user_conf")
650 import_fail_info("ipy_user_conf")
651
651
652 # finally, push the argv to options again to ensure highest priority
652 # finally, push the argv to options again to ensure highest priority
653 IP_rc.update(opts)
653 IP_rc.update(opts)
654
654
655 # release stdout and stderr and save config log into a global summary
655 # release stdout and stderr and save config log into a global summary
656 msg.config.release_all()
656 msg.config.release_all()
657 if IP_rc.messages:
657 if IP_rc.messages:
658 msg.summary += msg.config.summary_all()
658 msg.summary += msg.config.summary_all()
659
659
660 #------------------------------------------------------------------------
660 #------------------------------------------------------------------------
661 # Setup interactive session
661 # Setup interactive session
662
662
663 # Now we should be fully configured. We can then execute files or load
663 # Now we should be fully configured. We can then execute files or load
664 # things only needed for interactive use. Then we'll open the shell.
664 # things only needed for interactive use. Then we'll open the shell.
665
665
666 # Take a snapshot of the user namespace before opening the shell. That way
666 # Take a snapshot of the user namespace before opening the shell. That way
667 # we'll be able to identify which things were interactively defined and
667 # we'll be able to identify which things were interactively defined and
668 # which were defined through config files.
668 # which were defined through config files.
669 IP.user_config_ns.update(IP.user_ns)
669 IP.user_config_ns.update(IP.user_ns)
670
670
671 # Force reading a file as if it were a session log. Slower but safer.
671 # Force reading a file as if it were a session log. Slower but safer.
672 if load_logplay:
672 if load_logplay:
673 print 'Replaying log...'
673 print 'Replaying log...'
674 try:
674 try:
675 if IP_rc.debug:
675 if IP_rc.debug:
676 logplay_quiet = 0
676 logplay_quiet = 0
677 else:
677 else:
678 logplay_quiet = 1
678 logplay_quiet = 1
679
679
680 msg.logplay.trap_all()
680 msg.logplay.trap_all()
681 IP.safe_execfile(load_logplay,IP.user_ns,
681 IP.safe_execfile(load_logplay,IP.user_ns,
682 islog = 1, quiet = logplay_quiet)
682 islog = 1, quiet = logplay_quiet)
683 msg.logplay.release_all()
683 msg.logplay.release_all()
684 if IP_rc.messages:
684 if IP_rc.messages:
685 msg.summary += msg.logplay.summary_all()
685 msg.summary += msg.logplay.summary_all()
686 except:
686 except:
687 warn('Problems replaying logfile %s.' % load_logplay)
687 warn('Problems replaying logfile %s.' % load_logplay)
688 IP.InteractiveTB()
688 IP.InteractiveTB()
689
689
690 # Load remaining files in command line
690 # Load remaining files in command line
691 msg.user_exec.trap_all()
691 msg.user_exec.trap_all()
692
692
693 # Do NOT execute files named in the command line as scripts to be loaded
693 # Do NOT execute files named in the command line as scripts to be loaded
694 # by embedded instances. Doing so has the potential for an infinite
694 # by embedded instances. Doing so has the potential for an infinite
695 # recursion if there are exceptions thrown in the process.
695 # recursion if there are exceptions thrown in the process.
696
696
697 # XXX FIXME: the execution of user files should be moved out to after
697 # XXX FIXME: the execution of user files should be moved out to after
698 # ipython is fully initialized, just as if they were run via %run at the
698 # ipython is fully initialized, just as if they were run via %run at the
699 # ipython prompt. This would also give them the benefit of ipython's
699 # ipython prompt. This would also give them the benefit of ipython's
700 # nice tracebacks.
700 # nice tracebacks.
701
701
702 if (not embedded and IP_rc.args and
702 if (not embedded and IP_rc.args and
703 not IP_rc.args[0].lower().endswith('.ipy')):
703 not IP_rc.args[0].lower().endswith('.ipy')):
704 name_save = IP.user_ns['__name__']
704 name_save = IP.user_ns['__name__']
705 IP.user_ns['__name__'] = '__main__'
705 IP.user_ns['__name__'] = '__main__'
706 # Set our own excepthook in case the user code tries to call it
706 # Set our own excepthook in case the user code tries to call it
707 # directly. This prevents triggering the IPython crash handler.
707 # directly. This prevents triggering the IPython crash handler.
708 old_excepthook,sys.excepthook = sys.excepthook, IP.excepthook
708 old_excepthook,sys.excepthook = sys.excepthook, IP.excepthook
709
709
710 save_argv = sys.argv[1:] # save it for later restoring
710 save_argv = sys.argv[1:] # save it for later restoring
711
711
712 sys.argv = args
712 sys.argv = args
713
713
714 try:
714 try:
715 IP.safe_execfile(args[0], IP.user_ns)
715 IP.safe_execfile(args[0], IP.user_ns)
716 finally:
716 finally:
717 # Reset our crash handler in place
717 # Reset our crash handler in place
718 sys.excepthook = old_excepthook
718 sys.excepthook = old_excepthook
719 sys.argv[:] = save_argv
719 sys.argv[:] = save_argv
720 IP.user_ns['__name__'] = name_save
720 IP.user_ns['__name__'] = name_save
721
721
722 msg.user_exec.release_all()
722 msg.user_exec.release_all()
723
723
724 if IP_rc.messages:
724 if IP_rc.messages:
725 msg.summary += msg.user_exec.summary_all()
725 msg.summary += msg.user_exec.summary_all()
726
726
727 # since we can't specify a null string on the cmd line, 0 is the equivalent:
727 # since we can't specify a null string on the cmd line, 0 is the equivalent:
728 if IP_rc.nosep:
728 if IP_rc.nosep:
729 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
729 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
730 if IP_rc.separate_in == '0': IP_rc.separate_in = ''
730 if IP_rc.separate_in == '0': IP_rc.separate_in = ''
731 if IP_rc.separate_out == '0': IP_rc.separate_out = ''
731 if IP_rc.separate_out == '0': IP_rc.separate_out = ''
732 if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = ''
732 if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = ''
733 IP_rc.separate_in = IP_rc.separate_in.replace('\\n','\n')
733 IP_rc.separate_in = IP_rc.separate_in.replace('\\n','\n')
734 IP_rc.separate_out = IP_rc.separate_out.replace('\\n','\n')
734 IP_rc.separate_out = IP_rc.separate_out.replace('\\n','\n')
735 IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n','\n')
735 IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n','\n')
736
736
737 # Determine how many lines at the bottom of the screen are needed for
737 # Determine how many lines at the bottom of the screen are needed for
738 # showing prompts, so we can know wheter long strings are to be printed or
738 # showing prompts, so we can know wheter long strings are to be printed or
739 # paged:
739 # paged:
740 num_lines_bot = IP_rc.separate_in.count('\n')+1
740 num_lines_bot = IP_rc.separate_in.count('\n')+1
741 IP_rc.screen_length = IP_rc.screen_length - num_lines_bot
741 IP_rc.screen_length = IP_rc.screen_length - num_lines_bot
742
742
743 # configure startup banner
743 # configure startup banner
744 if IP_rc.c: # regular python doesn't print the banner with -c
744 if IP_rc.c: # regular python doesn't print the banner with -c
745 IP_rc.banner = 0
745 IP_rc.banner = 0
746 if IP_rc.banner:
746 if IP_rc.banner:
747 BANN_P = IP.BANNER_PARTS
747 BANN_P = IP.BANNER_PARTS
748 else:
748 else:
749 BANN_P = []
749 BANN_P = []
750
750
751 if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile)
751 if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile)
752
752
753 # add message log (possibly empty)
753 # add message log (possibly empty)
754 if msg.summary: BANN_P.append(msg.summary)
754 if msg.summary: BANN_P.append(msg.summary)
755 # Final banner is a string
755 # Final banner is a string
756 IP.BANNER = '\n'.join(BANN_P)
756 IP.BANNER = '\n'.join(BANN_P)
757
757
758 # Finalize the IPython instance. This assumes the rc structure is fully
758 # Finalize the IPython instance. This assumes the rc structure is fully
759 # in place.
759 # in place.
760 IP.post_config_initialization()
760 IP.post_config_initialization()
761
761
762 return IP
762 return IP
763 #************************ end of file <ipmaker.py> **************************
763 #************************ end of file <ipmaker.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