##// END OF EJS Templates
substitute open(...) for file(...)...
Brandon Parsons -
Show More
@@ -1,3798 +1,3798 b''
1 # encoding: utf-8
1 # encoding: utf-8
2 """Magic functions for InteractiveShell.
2 """Magic functions for InteractiveShell.
3 """
3 """
4
4
5 #-----------------------------------------------------------------------------
5 #-----------------------------------------------------------------------------
6 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
6 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
7 # Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
7 # Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
8 # Copyright (C) 2008-2011 The IPython Development Team
8 # Copyright (C) 2008-2011 The IPython Development Team
9
9
10 # Distributed under the terms of the BSD License. The full license is in
10 # Distributed under the terms of the BSD License. The full license is in
11 # the file COPYING, distributed as part of this software.
11 # the file COPYING, distributed as part of this software.
12 #-----------------------------------------------------------------------------
12 #-----------------------------------------------------------------------------
13
13
14 #-----------------------------------------------------------------------------
14 #-----------------------------------------------------------------------------
15 # Imports
15 # Imports
16 #-----------------------------------------------------------------------------
16 #-----------------------------------------------------------------------------
17
17
18 import __builtin__ as builtin_mod
18 import __builtin__ as builtin_mod
19 import __future__
19 import __future__
20 import bdb
20 import bdb
21 import inspect
21 import inspect
22 import imp
22 import imp
23 import io
23 import io
24 import os
24 import os
25 import sys
25 import sys
26 import shutil
26 import shutil
27 import re
27 import re
28 import time
28 import time
29 import gc
29 import gc
30 from StringIO import StringIO
30 from StringIO import StringIO
31 from getopt import getopt,GetoptError
31 from getopt import getopt,GetoptError
32 from pprint import pformat
32 from pprint import pformat
33 from xmlrpclib import ServerProxy
33 from xmlrpclib import ServerProxy
34
34
35 # cProfile was added in Python2.5
35 # cProfile was added in Python2.5
36 try:
36 try:
37 import cProfile as profile
37 import cProfile as profile
38 import pstats
38 import pstats
39 except ImportError:
39 except ImportError:
40 # profile isn't bundled by default in Debian for license reasons
40 # profile isn't bundled by default in Debian for license reasons
41 try:
41 try:
42 import profile,pstats
42 import profile,pstats
43 except ImportError:
43 except ImportError:
44 profile = pstats = None
44 profile = pstats = None
45
45
46 import IPython
46 import IPython
47 from IPython.core import debugger, oinspect
47 from IPython.core import debugger, oinspect
48 from IPython.core.error import TryNext
48 from IPython.core.error import TryNext
49 from IPython.core.error import UsageError
49 from IPython.core.error import UsageError
50 from IPython.core.error import StdinNotImplementedError
50 from IPython.core.error import StdinNotImplementedError
51 from IPython.core.fakemodule import FakeModule
51 from IPython.core.fakemodule import FakeModule
52 from IPython.core.profiledir import ProfileDir
52 from IPython.core.profiledir import ProfileDir
53 from IPython.core.macro import Macro
53 from IPython.core.macro import Macro
54 from IPython.core import magic_arguments, page
54 from IPython.core import magic_arguments, page
55 from IPython.core.prefilter import ESC_MAGIC
55 from IPython.core.prefilter import ESC_MAGIC
56 from IPython.core.pylabtools import mpl_runner
56 from IPython.core.pylabtools import mpl_runner
57 from IPython.testing.skipdoctest import skip_doctest
57 from IPython.testing.skipdoctest import skip_doctest
58 from IPython.utils import py3compat
58 from IPython.utils import py3compat
59 from IPython.utils import openpy
59 from IPython.utils import openpy
60 from IPython.utils.io import file_read, nlprint
60 from IPython.utils.io import file_read, nlprint
61 from IPython.utils.module_paths import find_mod
61 from IPython.utils.module_paths import find_mod
62 from IPython.utils.path import get_py_filename, unquote_filename
62 from IPython.utils.path import get_py_filename, unquote_filename
63 from IPython.utils.process import arg_split, abbrev_cwd
63 from IPython.utils.process import arg_split, abbrev_cwd
64 from IPython.utils.terminal import set_term_title
64 from IPython.utils.terminal import set_term_title
65 from IPython.utils.text import LSString, SList, format_screen
65 from IPython.utils.text import LSString, SList, format_screen
66 from IPython.utils.timing import clock, clock2
66 from IPython.utils.timing import clock, clock2
67 from IPython.utils.warn import warn, error
67 from IPython.utils.warn import warn, error
68 from IPython.utils.ipstruct import Struct
68 from IPython.utils.ipstruct import Struct
69 from IPython.config.application import Application
69 from IPython.config.application import Application
70
70
71 #-----------------------------------------------------------------------------
71 #-----------------------------------------------------------------------------
72 # Utility functions
72 # Utility functions
73 #-----------------------------------------------------------------------------
73 #-----------------------------------------------------------------------------
74
74
75 def on_off(tag):
75 def on_off(tag):
76 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
76 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
77 return ['OFF','ON'][tag]
77 return ['OFF','ON'][tag]
78
78
79 class Bunch: pass
79 class Bunch: pass
80
80
81 def compress_dhist(dh):
81 def compress_dhist(dh):
82 head, tail = dh[:-10], dh[-10:]
82 head, tail = dh[:-10], dh[-10:]
83
83
84 newhead = []
84 newhead = []
85 done = set()
85 done = set()
86 for h in head:
86 for h in head:
87 if h in done:
87 if h in done:
88 continue
88 continue
89 newhead.append(h)
89 newhead.append(h)
90 done.add(h)
90 done.add(h)
91
91
92 return newhead + tail
92 return newhead + tail
93
93
94 def needs_local_scope(func):
94 def needs_local_scope(func):
95 """Decorator to mark magic functions which need to local scope to run."""
95 """Decorator to mark magic functions which need to local scope to run."""
96 func.needs_local_scope = True
96 func.needs_local_scope = True
97 return func
97 return func
98
98
99
99
100 # Used for exception handling in magic_edit
100 # Used for exception handling in magic_edit
101 class MacroToEdit(ValueError): pass
101 class MacroToEdit(ValueError): pass
102
102
103 #***************************************************************************
103 #***************************************************************************
104 # Main class implementing Magic functionality
104 # Main class implementing Magic functionality
105
105
106 # XXX - for some odd reason, if Magic is made a new-style class, we get errors
106 # XXX - for some odd reason, if Magic is made a new-style class, we get errors
107 # on construction of the main InteractiveShell object. Something odd is going
107 # on construction of the main InteractiveShell object. Something odd is going
108 # on with super() calls, Configurable and the MRO... For now leave it as-is, but
108 # on with super() calls, Configurable and the MRO... For now leave it as-is, but
109 # eventually this needs to be clarified.
109 # eventually this needs to be clarified.
110 # BG: This is because InteractiveShell inherits from this, but is itself a
110 # BG: This is because InteractiveShell inherits from this, but is itself a
111 # Configurable. This messes up the MRO in some way. The fix is that we need to
111 # Configurable. This messes up the MRO in some way. The fix is that we need to
112 # make Magic a configurable that InteractiveShell does not subclass.
112 # make Magic a configurable that InteractiveShell does not subclass.
113
113
114 class Magic:
114 class Magic:
115 """Magic functions for InteractiveShell.
115 """Magic functions for InteractiveShell.
116
116
117 Shell functions which can be reached as %function_name. All magic
117 Shell functions which can be reached as %function_name. All magic
118 functions should accept a string, which they can parse for their own
118 functions should accept a string, which they can parse for their own
119 needs. This can make some functions easier to type, eg `%cd ../`
119 needs. This can make some functions easier to type, eg `%cd ../`
120 vs. `%cd("../")`
120 vs. `%cd("../")`
121
121
122 ALL definitions MUST begin with the prefix magic_. The user won't need it
122 ALL definitions MUST begin with the prefix magic_. The user won't need it
123 at the command line, but it is is needed in the definition. """
123 at the command line, but it is is needed in the definition. """
124
124
125 # class globals
125 # class globals
126 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
126 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
127 'Automagic is ON, % prefix NOT needed for magic functions.']
127 'Automagic is ON, % prefix NOT needed for magic functions.']
128
128
129
129
130 configurables = None
130 configurables = None
131 #......................................................................
131 #......................................................................
132 # some utility functions
132 # some utility functions
133
133
134 def __init__(self,shell):
134 def __init__(self,shell):
135
135
136 self.options_table = {}
136 self.options_table = {}
137 if profile is None:
137 if profile is None:
138 self.magic_prun = self.profile_missing_notice
138 self.magic_prun = self.profile_missing_notice
139 self.shell = shell
139 self.shell = shell
140 if self.configurables is None:
140 if self.configurables is None:
141 self.configurables = []
141 self.configurables = []
142
142
143 # namespace for holding state we may need
143 # namespace for holding state we may need
144 self._magic_state = Bunch()
144 self._magic_state = Bunch()
145
145
146 def profile_missing_notice(self, *args, **kwargs):
146 def profile_missing_notice(self, *args, **kwargs):
147 error("""\
147 error("""\
148 The profile module could not be found. It has been removed from the standard
148 The profile module could not be found. It has been removed from the standard
149 python packages because of its non-free license. To use profiling, install the
149 python packages because of its non-free license. To use profiling, install the
150 python-profiler package from non-free.""")
150 python-profiler package from non-free.""")
151
151
152 def default_option(self,fn,optstr):
152 def default_option(self,fn,optstr):
153 """Make an entry in the options_table for fn, with value optstr"""
153 """Make an entry in the options_table for fn, with value optstr"""
154
154
155 if fn not in self.lsmagic():
155 if fn not in self.lsmagic():
156 error("%s is not a magic function" % fn)
156 error("%s is not a magic function" % fn)
157 self.options_table[fn] = optstr
157 self.options_table[fn] = optstr
158
158
159 def lsmagic(self):
159 def lsmagic(self):
160 """Return a list of currently available magic functions.
160 """Return a list of currently available magic functions.
161
161
162 Gives a list of the bare names after mangling (['ls','cd', ...], not
162 Gives a list of the bare names after mangling (['ls','cd', ...], not
163 ['magic_ls','magic_cd',...]"""
163 ['magic_ls','magic_cd',...]"""
164
164
165 # FIXME. This needs a cleanup, in the way the magics list is built.
165 # FIXME. This needs a cleanup, in the way the magics list is built.
166
166
167 # magics in class definition
167 # magics in class definition
168 class_magic = lambda fn: fn.startswith('magic_') and \
168 class_magic = lambda fn: fn.startswith('magic_') and \
169 callable(Magic.__dict__[fn])
169 callable(Magic.__dict__[fn])
170 # in instance namespace (run-time user additions)
170 # in instance namespace (run-time user additions)
171 inst_magic = lambda fn: fn.startswith('magic_') and \
171 inst_magic = lambda fn: fn.startswith('magic_') and \
172 callable(self.__dict__[fn])
172 callable(self.__dict__[fn])
173 # and bound magics by user (so they can access self):
173 # and bound magics by user (so they can access self):
174 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
174 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
175 callable(self.__class__.__dict__[fn])
175 callable(self.__class__.__dict__[fn])
176 magics = filter(class_magic,Magic.__dict__.keys()) + \
176 magics = filter(class_magic,Magic.__dict__.keys()) + \
177 filter(inst_magic,self.__dict__.keys()) + \
177 filter(inst_magic,self.__dict__.keys()) + \
178 filter(inst_bound_magic,self.__class__.__dict__.keys())
178 filter(inst_bound_magic,self.__class__.__dict__.keys())
179 out = []
179 out = []
180 for fn in set(magics):
180 for fn in set(magics):
181 out.append(fn.replace('magic_','',1))
181 out.append(fn.replace('magic_','',1))
182 out.sort()
182 out.sort()
183 return out
183 return out
184
184
185 def extract_input_lines(self, range_str, raw=False):
185 def extract_input_lines(self, range_str, raw=False):
186 """Return as a string a set of input history slices.
186 """Return as a string a set of input history slices.
187
187
188 Parameters
188 Parameters
189 ----------
189 ----------
190 range_str : string
190 range_str : string
191 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
191 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
192 since this function is for use by magic functions which get their
192 since this function is for use by magic functions which get their
193 arguments as strings. The number before the / is the session
193 arguments as strings. The number before the / is the session
194 number: ~n goes n back from the current session.
194 number: ~n goes n back from the current session.
195
195
196 Optional Parameters:
196 Optional Parameters:
197 - raw(False): by default, the processed input is used. If this is
197 - raw(False): by default, the processed input is used. If this is
198 true, the raw input history is used instead.
198 true, the raw input history is used instead.
199
199
200 Note that slices can be called with two notations:
200 Note that slices can be called with two notations:
201
201
202 N:M -> standard python form, means including items N...(M-1).
202 N:M -> standard python form, means including items N...(M-1).
203
203
204 N-M -> include items N..M (closed endpoint)."""
204 N-M -> include items N..M (closed endpoint)."""
205 lines = self.shell.history_manager.\
205 lines = self.shell.history_manager.\
206 get_range_by_str(range_str, raw=raw)
206 get_range_by_str(range_str, raw=raw)
207 return "\n".join(x for _, _, x in lines)
207 return "\n".join(x for _, _, x in lines)
208
208
209 def arg_err(self,func):
209 def arg_err(self,func):
210 """Print docstring if incorrect arguments were passed"""
210 """Print docstring if incorrect arguments were passed"""
211 print 'Error in arguments:'
211 print 'Error in arguments:'
212 print oinspect.getdoc(func)
212 print oinspect.getdoc(func)
213
213
214 def format_latex(self,strng):
214 def format_latex(self,strng):
215 """Format a string for latex inclusion."""
215 """Format a string for latex inclusion."""
216
216
217 # Characters that need to be escaped for latex:
217 # Characters that need to be escaped for latex:
218 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
218 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
219 # Magic command names as headers:
219 # Magic command names as headers:
220 cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
220 cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
221 re.MULTILINE)
221 re.MULTILINE)
222 # Magic commands
222 # Magic commands
223 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
223 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
224 re.MULTILINE)
224 re.MULTILINE)
225 # Paragraph continue
225 # Paragraph continue
226 par_re = re.compile(r'\\$',re.MULTILINE)
226 par_re = re.compile(r'\\$',re.MULTILINE)
227
227
228 # The "\n" symbol
228 # The "\n" symbol
229 newline_re = re.compile(r'\\n')
229 newline_re = re.compile(r'\\n')
230
230
231 # Now build the string for output:
231 # Now build the string for output:
232 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
232 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
233 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
233 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
234 strng)
234 strng)
235 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
235 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
236 strng = par_re.sub(r'\\\\',strng)
236 strng = par_re.sub(r'\\\\',strng)
237 strng = escape_re.sub(r'\\\1',strng)
237 strng = escape_re.sub(r'\\\1',strng)
238 strng = newline_re.sub(r'\\textbackslash{}n',strng)
238 strng = newline_re.sub(r'\\textbackslash{}n',strng)
239 return strng
239 return strng
240
240
241 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
241 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
242 """Parse options passed to an argument string.
242 """Parse options passed to an argument string.
243
243
244 The interface is similar to that of getopt(), but it returns back a
244 The interface is similar to that of getopt(), but it returns back a
245 Struct with the options as keys and the stripped argument string still
245 Struct with the options as keys and the stripped argument string still
246 as a string.
246 as a string.
247
247
248 arg_str is quoted as a true sys.argv vector by using shlex.split.
248 arg_str is quoted as a true sys.argv vector by using shlex.split.
249 This allows us to easily expand variables, glob files, quote
249 This allows us to easily expand variables, glob files, quote
250 arguments, etc.
250 arguments, etc.
251
251
252 Options:
252 Options:
253 -mode: default 'string'. If given as 'list', the argument string is
253 -mode: default 'string'. If given as 'list', the argument string is
254 returned as a list (split on whitespace) instead of a string.
254 returned as a list (split on whitespace) instead of a string.
255
255
256 -list_all: put all option values in lists. Normally only options
256 -list_all: put all option values in lists. Normally only options
257 appearing more than once are put in a list.
257 appearing more than once are put in a list.
258
258
259 -posix (True): whether to split the input line in POSIX mode or not,
259 -posix (True): whether to split the input line in POSIX mode or not,
260 as per the conventions outlined in the shlex module from the
260 as per the conventions outlined in the shlex module from the
261 standard library."""
261 standard library."""
262
262
263 # inject default options at the beginning of the input line
263 # inject default options at the beginning of the input line
264 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
264 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
265 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
265 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
266
266
267 mode = kw.get('mode','string')
267 mode = kw.get('mode','string')
268 if mode not in ['string','list']:
268 if mode not in ['string','list']:
269 raise ValueError,'incorrect mode given: %s' % mode
269 raise ValueError,'incorrect mode given: %s' % mode
270 # Get options
270 # Get options
271 list_all = kw.get('list_all',0)
271 list_all = kw.get('list_all',0)
272 posix = kw.get('posix', os.name == 'posix')
272 posix = kw.get('posix', os.name == 'posix')
273 strict = kw.get('strict', True)
273 strict = kw.get('strict', True)
274
274
275 # Check if we have more than one argument to warrant extra processing:
275 # Check if we have more than one argument to warrant extra processing:
276 odict = {} # Dictionary with options
276 odict = {} # Dictionary with options
277 args = arg_str.split()
277 args = arg_str.split()
278 if len(args) >= 1:
278 if len(args) >= 1:
279 # If the list of inputs only has 0 or 1 thing in it, there's no
279 # If the list of inputs only has 0 or 1 thing in it, there's no
280 # need to look for options
280 # need to look for options
281 argv = arg_split(arg_str, posix, strict)
281 argv = arg_split(arg_str, posix, strict)
282 # Do regular option processing
282 # Do regular option processing
283 try:
283 try:
284 opts,args = getopt(argv,opt_str,*long_opts)
284 opts,args = getopt(argv,opt_str,*long_opts)
285 except GetoptError,e:
285 except GetoptError,e:
286 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
286 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
287 " ".join(long_opts)))
287 " ".join(long_opts)))
288 for o,a in opts:
288 for o,a in opts:
289 if o.startswith('--'):
289 if o.startswith('--'):
290 o = o[2:]
290 o = o[2:]
291 else:
291 else:
292 o = o[1:]
292 o = o[1:]
293 try:
293 try:
294 odict[o].append(a)
294 odict[o].append(a)
295 except AttributeError:
295 except AttributeError:
296 odict[o] = [odict[o],a]
296 odict[o] = [odict[o],a]
297 except KeyError:
297 except KeyError:
298 if list_all:
298 if list_all:
299 odict[o] = [a]
299 odict[o] = [a]
300 else:
300 else:
301 odict[o] = a
301 odict[o] = a
302
302
303 # Prepare opts,args for return
303 # Prepare opts,args for return
304 opts = Struct(odict)
304 opts = Struct(odict)
305 if mode == 'string':
305 if mode == 'string':
306 args = ' '.join(args)
306 args = ' '.join(args)
307
307
308 return opts,args
308 return opts,args
309
309
310 #......................................................................
310 #......................................................................
311 # And now the actual magic functions
311 # And now the actual magic functions
312
312
313 # Functions for IPython shell work (vars,funcs, config, etc)
313 # Functions for IPython shell work (vars,funcs, config, etc)
314 def magic_lsmagic(self, parameter_s = ''):
314 def magic_lsmagic(self, parameter_s = ''):
315 """List currently available magic functions."""
315 """List currently available magic functions."""
316 mesc = ESC_MAGIC
316 mesc = ESC_MAGIC
317 print 'Available magic functions:\n'+mesc+\
317 print 'Available magic functions:\n'+mesc+\
318 (' '+mesc).join(self.lsmagic())
318 (' '+mesc).join(self.lsmagic())
319 print '\n' + Magic.auto_status[self.shell.automagic]
319 print '\n' + Magic.auto_status[self.shell.automagic]
320 return None
320 return None
321
321
322 def magic_magic(self, parameter_s = ''):
322 def magic_magic(self, parameter_s = ''):
323 """Print information about the magic function system.
323 """Print information about the magic function system.
324
324
325 Supported formats: -latex, -brief, -rest
325 Supported formats: -latex, -brief, -rest
326 """
326 """
327
327
328 mode = ''
328 mode = ''
329 try:
329 try:
330 if parameter_s.split()[0] == '-latex':
330 if parameter_s.split()[0] == '-latex':
331 mode = 'latex'
331 mode = 'latex'
332 if parameter_s.split()[0] == '-brief':
332 if parameter_s.split()[0] == '-brief':
333 mode = 'brief'
333 mode = 'brief'
334 if parameter_s.split()[0] == '-rest':
334 if parameter_s.split()[0] == '-rest':
335 mode = 'rest'
335 mode = 'rest'
336 rest_docs = []
336 rest_docs = []
337 except:
337 except:
338 pass
338 pass
339
339
340 magic_docs = []
340 magic_docs = []
341 for fname in self.lsmagic():
341 for fname in self.lsmagic():
342 mname = 'magic_' + fname
342 mname = 'magic_' + fname
343 for space in (Magic,self,self.__class__):
343 for space in (Magic,self,self.__class__):
344 try:
344 try:
345 fn = space.__dict__[mname]
345 fn = space.__dict__[mname]
346 except KeyError:
346 except KeyError:
347 pass
347 pass
348 else:
348 else:
349 break
349 break
350 if mode == 'brief':
350 if mode == 'brief':
351 # only first line
351 # only first line
352 if fn.__doc__:
352 if fn.__doc__:
353 fndoc = fn.__doc__.split('\n',1)[0]
353 fndoc = fn.__doc__.split('\n',1)[0]
354 else:
354 else:
355 fndoc = 'No documentation'
355 fndoc = 'No documentation'
356 else:
356 else:
357 if fn.__doc__:
357 if fn.__doc__:
358 fndoc = fn.__doc__.rstrip()
358 fndoc = fn.__doc__.rstrip()
359 else:
359 else:
360 fndoc = 'No documentation'
360 fndoc = 'No documentation'
361
361
362
362
363 if mode == 'rest':
363 if mode == 'rest':
364 rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
364 rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
365 fname,fndoc))
365 fname,fndoc))
366
366
367 else:
367 else:
368 magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
368 magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
369 fname,fndoc))
369 fname,fndoc))
370
370
371 magic_docs = ''.join(magic_docs)
371 magic_docs = ''.join(magic_docs)
372
372
373 if mode == 'rest':
373 if mode == 'rest':
374 return "".join(rest_docs)
374 return "".join(rest_docs)
375
375
376 if mode == 'latex':
376 if mode == 'latex':
377 print self.format_latex(magic_docs)
377 print self.format_latex(magic_docs)
378 return
378 return
379 else:
379 else:
380 magic_docs = format_screen(magic_docs)
380 magic_docs = format_screen(magic_docs)
381 if mode == 'brief':
381 if mode == 'brief':
382 return magic_docs
382 return magic_docs
383
383
384 outmsg = """
384 outmsg = """
385 IPython's 'magic' functions
385 IPython's 'magic' functions
386 ===========================
386 ===========================
387
387
388 The magic function system provides a series of functions which allow you to
388 The magic function system provides a series of functions which allow you to
389 control the behavior of IPython itself, plus a lot of system-type
389 control the behavior of IPython itself, plus a lot of system-type
390 features. All these functions are prefixed with a % character, but parameters
390 features. All these functions are prefixed with a % character, but parameters
391 are given without parentheses or quotes.
391 are given without parentheses or quotes.
392
392
393 NOTE: If you have 'automagic' enabled (via the command line option or with the
393 NOTE: If you have 'automagic' enabled (via the command line option or with the
394 %automagic function), you don't need to type in the % explicitly. By default,
394 %automagic function), you don't need to type in the % explicitly. By default,
395 IPython ships with automagic on, so you should only rarely need the % escape.
395 IPython ships with automagic on, so you should only rarely need the % escape.
396
396
397 Example: typing '%cd mydir' (without the quotes) changes you working directory
397 Example: typing '%cd mydir' (without the quotes) changes you working directory
398 to 'mydir', if it exists.
398 to 'mydir', if it exists.
399
399
400 For a list of the available magic functions, use %lsmagic. For a description
400 For a list of the available magic functions, use %lsmagic. For a description
401 of any of them, type %magic_name?, e.g. '%cd?'.
401 of any of them, type %magic_name?, e.g. '%cd?'.
402
402
403 Currently the magic system has the following functions:\n"""
403 Currently the magic system has the following functions:\n"""
404
404
405 mesc = ESC_MAGIC
405 mesc = ESC_MAGIC
406 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
406 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
407 "\n\n%s%s\n\n%s" % (outmsg,
407 "\n\n%s%s\n\n%s" % (outmsg,
408 magic_docs,mesc,mesc,
408 magic_docs,mesc,mesc,
409 (' '+mesc).join(self.lsmagic()),
409 (' '+mesc).join(self.lsmagic()),
410 Magic.auto_status[self.shell.automagic] ) )
410 Magic.auto_status[self.shell.automagic] ) )
411 page.page(outmsg)
411 page.page(outmsg)
412
412
413 def magic_automagic(self, parameter_s = ''):
413 def magic_automagic(self, parameter_s = ''):
414 """Make magic functions callable without having to type the initial %.
414 """Make magic functions callable without having to type the initial %.
415
415
416 Without argumentsl toggles on/off (when off, you must call it as
416 Without argumentsl toggles on/off (when off, you must call it as
417 %automagic, of course). With arguments it sets the value, and you can
417 %automagic, of course). With arguments it sets the value, and you can
418 use any of (case insensitive):
418 use any of (case insensitive):
419
419
420 - on,1,True: to activate
420 - on,1,True: to activate
421
421
422 - off,0,False: to deactivate.
422 - off,0,False: to deactivate.
423
423
424 Note that magic functions have lowest priority, so if there's a
424 Note that magic functions have lowest priority, so if there's a
425 variable whose name collides with that of a magic fn, automagic won't
425 variable whose name collides with that of a magic fn, automagic won't
426 work for that function (you get the variable instead). However, if you
426 work for that function (you get the variable instead). However, if you
427 delete the variable (del var), the previously shadowed magic function
427 delete the variable (del var), the previously shadowed magic function
428 becomes visible to automagic again."""
428 becomes visible to automagic again."""
429
429
430 arg = parameter_s.lower()
430 arg = parameter_s.lower()
431 if parameter_s in ('on','1','true'):
431 if parameter_s in ('on','1','true'):
432 self.shell.automagic = True
432 self.shell.automagic = True
433 elif parameter_s in ('off','0','false'):
433 elif parameter_s in ('off','0','false'):
434 self.shell.automagic = False
434 self.shell.automagic = False
435 else:
435 else:
436 self.shell.automagic = not self.shell.automagic
436 self.shell.automagic = not self.shell.automagic
437 print '\n' + Magic.auto_status[self.shell.automagic]
437 print '\n' + Magic.auto_status[self.shell.automagic]
438
438
439 @skip_doctest
439 @skip_doctest
440 def magic_autocall(self, parameter_s = ''):
440 def magic_autocall(self, parameter_s = ''):
441 """Make functions callable without having to type parentheses.
441 """Make functions callable without having to type parentheses.
442
442
443 Usage:
443 Usage:
444
444
445 %autocall [mode]
445 %autocall [mode]
446
446
447 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
447 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
448 value is toggled on and off (remembering the previous state).
448 value is toggled on and off (remembering the previous state).
449
449
450 In more detail, these values mean:
450 In more detail, these values mean:
451
451
452 0 -> fully disabled
452 0 -> fully disabled
453
453
454 1 -> active, but do not apply if there are no arguments on the line.
454 1 -> active, but do not apply if there are no arguments on the line.
455
455
456 In this mode, you get::
456 In this mode, you get::
457
457
458 In [1]: callable
458 In [1]: callable
459 Out[1]: <built-in function callable>
459 Out[1]: <built-in function callable>
460
460
461 In [2]: callable 'hello'
461 In [2]: callable 'hello'
462 ------> callable('hello')
462 ------> callable('hello')
463 Out[2]: False
463 Out[2]: False
464
464
465 2 -> Active always. Even if no arguments are present, the callable
465 2 -> Active always. Even if no arguments are present, the callable
466 object is called::
466 object is called::
467
467
468 In [2]: float
468 In [2]: float
469 ------> float()
469 ------> float()
470 Out[2]: 0.0
470 Out[2]: 0.0
471
471
472 Note that even with autocall off, you can still use '/' at the start of
472 Note that even with autocall off, you can still use '/' at the start of
473 a line to treat the first argument on the command line as a function
473 a line to treat the first argument on the command line as a function
474 and add parentheses to it::
474 and add parentheses to it::
475
475
476 In [8]: /str 43
476 In [8]: /str 43
477 ------> str(43)
477 ------> str(43)
478 Out[8]: '43'
478 Out[8]: '43'
479
479
480 # all-random (note for auto-testing)
480 # all-random (note for auto-testing)
481 """
481 """
482
482
483 if parameter_s:
483 if parameter_s:
484 arg = int(parameter_s)
484 arg = int(parameter_s)
485 else:
485 else:
486 arg = 'toggle'
486 arg = 'toggle'
487
487
488 if not arg in (0,1,2,'toggle'):
488 if not arg in (0,1,2,'toggle'):
489 error('Valid modes: (0->Off, 1->Smart, 2->Full')
489 error('Valid modes: (0->Off, 1->Smart, 2->Full')
490 return
490 return
491
491
492 if arg in (0,1,2):
492 if arg in (0,1,2):
493 self.shell.autocall = arg
493 self.shell.autocall = arg
494 else: # toggle
494 else: # toggle
495 if self.shell.autocall:
495 if self.shell.autocall:
496 self._magic_state.autocall_save = self.shell.autocall
496 self._magic_state.autocall_save = self.shell.autocall
497 self.shell.autocall = 0
497 self.shell.autocall = 0
498 else:
498 else:
499 try:
499 try:
500 self.shell.autocall = self._magic_state.autocall_save
500 self.shell.autocall = self._magic_state.autocall_save
501 except AttributeError:
501 except AttributeError:
502 self.shell.autocall = self._magic_state.autocall_save = 1
502 self.shell.autocall = self._magic_state.autocall_save = 1
503
503
504 print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
504 print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
505
505
506
506
507 def magic_page(self, parameter_s=''):
507 def magic_page(self, parameter_s=''):
508 """Pretty print the object and display it through a pager.
508 """Pretty print the object and display it through a pager.
509
509
510 %page [options] OBJECT
510 %page [options] OBJECT
511
511
512 If no object is given, use _ (last output).
512 If no object is given, use _ (last output).
513
513
514 Options:
514 Options:
515
515
516 -r: page str(object), don't pretty-print it."""
516 -r: page str(object), don't pretty-print it."""
517
517
518 # After a function contributed by Olivier Aubert, slightly modified.
518 # After a function contributed by Olivier Aubert, slightly modified.
519
519
520 # Process options/args
520 # Process options/args
521 opts,args = self.parse_options(parameter_s,'r')
521 opts,args = self.parse_options(parameter_s,'r')
522 raw = 'r' in opts
522 raw = 'r' in opts
523
523
524 oname = args and args or '_'
524 oname = args and args or '_'
525 info = self._ofind(oname)
525 info = self._ofind(oname)
526 if info['found']:
526 if info['found']:
527 txt = (raw and str or pformat)( info['obj'] )
527 txt = (raw and str or pformat)( info['obj'] )
528 page.page(txt)
528 page.page(txt)
529 else:
529 else:
530 print 'Object `%s` not found' % oname
530 print 'Object `%s` not found' % oname
531
531
532 def magic_profile(self, parameter_s=''):
532 def magic_profile(self, parameter_s=''):
533 """Print your currently active IPython profile."""
533 """Print your currently active IPython profile."""
534 from IPython.core.application import BaseIPythonApplication
534 from IPython.core.application import BaseIPythonApplication
535 if BaseIPythonApplication.initialized():
535 if BaseIPythonApplication.initialized():
536 print BaseIPythonApplication.instance().profile
536 print BaseIPythonApplication.instance().profile
537 else:
537 else:
538 error("profile is an application-level value, but you don't appear to be in an IPython application")
538 error("profile is an application-level value, but you don't appear to be in an IPython application")
539
539
540 def magic_pinfo(self, parameter_s='', namespaces=None):
540 def magic_pinfo(self, parameter_s='', namespaces=None):
541 """Provide detailed information about an object.
541 """Provide detailed information about an object.
542
542
543 '%pinfo object' is just a synonym for object? or ?object."""
543 '%pinfo object' is just a synonym for object? or ?object."""
544
544
545 #print 'pinfo par: <%s>' % parameter_s # dbg
545 #print 'pinfo par: <%s>' % parameter_s # dbg
546
546
547
547
548 # detail_level: 0 -> obj? , 1 -> obj??
548 # detail_level: 0 -> obj? , 1 -> obj??
549 detail_level = 0
549 detail_level = 0
550 # We need to detect if we got called as 'pinfo pinfo foo', which can
550 # We need to detect if we got called as 'pinfo pinfo foo', which can
551 # happen if the user types 'pinfo foo?' at the cmd line.
551 # happen if the user types 'pinfo foo?' at the cmd line.
552 pinfo,qmark1,oname,qmark2 = \
552 pinfo,qmark1,oname,qmark2 = \
553 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
553 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
554 if pinfo or qmark1 or qmark2:
554 if pinfo or qmark1 or qmark2:
555 detail_level = 1
555 detail_level = 1
556 if "*" in oname:
556 if "*" in oname:
557 self.magic_psearch(oname)
557 self.magic_psearch(oname)
558 else:
558 else:
559 self.shell._inspect('pinfo', oname, detail_level=detail_level,
559 self.shell._inspect('pinfo', oname, detail_level=detail_level,
560 namespaces=namespaces)
560 namespaces=namespaces)
561
561
562 def magic_pinfo2(self, parameter_s='', namespaces=None):
562 def magic_pinfo2(self, parameter_s='', namespaces=None):
563 """Provide extra detailed information about an object.
563 """Provide extra detailed information about an object.
564
564
565 '%pinfo2 object' is just a synonym for object?? or ??object."""
565 '%pinfo2 object' is just a synonym for object?? or ??object."""
566 self.shell._inspect('pinfo', parameter_s, detail_level=1,
566 self.shell._inspect('pinfo', parameter_s, detail_level=1,
567 namespaces=namespaces)
567 namespaces=namespaces)
568
568
569 @skip_doctest
569 @skip_doctest
570 def magic_pdef(self, parameter_s='', namespaces=None):
570 def magic_pdef(self, parameter_s='', namespaces=None):
571 """Print the definition header for any callable object.
571 """Print the definition header for any callable object.
572
572
573 If the object is a class, print the constructor information.
573 If the object is a class, print the constructor information.
574
574
575 Examples
575 Examples
576 --------
576 --------
577 ::
577 ::
578
578
579 In [3]: %pdef urllib.urlopen
579 In [3]: %pdef urllib.urlopen
580 urllib.urlopen(url, data=None, proxies=None)
580 urllib.urlopen(url, data=None, proxies=None)
581 """
581 """
582 self._inspect('pdef',parameter_s, namespaces)
582 self._inspect('pdef',parameter_s, namespaces)
583
583
584 def magic_pdoc(self, parameter_s='', namespaces=None):
584 def magic_pdoc(self, parameter_s='', namespaces=None):
585 """Print the docstring for an object.
585 """Print the docstring for an object.
586
586
587 If the given object is a class, it will print both the class and the
587 If the given object is a class, it will print both the class and the
588 constructor docstrings."""
588 constructor docstrings."""
589 self._inspect('pdoc',parameter_s, namespaces)
589 self._inspect('pdoc',parameter_s, namespaces)
590
590
591 def magic_psource(self, parameter_s='', namespaces=None):
591 def magic_psource(self, parameter_s='', namespaces=None):
592 """Print (or run through pager) the source code for an object."""
592 """Print (or run through pager) the source code for an object."""
593 self._inspect('psource',parameter_s, namespaces)
593 self._inspect('psource',parameter_s, namespaces)
594
594
595 def magic_pfile(self, parameter_s=''):
595 def magic_pfile(self, parameter_s=''):
596 """Print (or run through pager) the file where an object is defined.
596 """Print (or run through pager) the file where an object is defined.
597
597
598 The file opens at the line where the object definition begins. IPython
598 The file opens at the line where the object definition begins. IPython
599 will honor the environment variable PAGER if set, and otherwise will
599 will honor the environment variable PAGER if set, and otherwise will
600 do its best to print the file in a convenient form.
600 do its best to print the file in a convenient form.
601
601
602 If the given argument is not an object currently defined, IPython will
602 If the given argument is not an object currently defined, IPython will
603 try to interpret it as a filename (automatically adding a .py extension
603 try to interpret it as a filename (automatically adding a .py extension
604 if needed). You can thus use %pfile as a syntax highlighting code
604 if needed). You can thus use %pfile as a syntax highlighting code
605 viewer."""
605 viewer."""
606
606
607 # first interpret argument as an object name
607 # first interpret argument as an object name
608 out = self._inspect('pfile',parameter_s)
608 out = self._inspect('pfile',parameter_s)
609 # if not, try the input as a filename
609 # if not, try the input as a filename
610 if out == 'not found':
610 if out == 'not found':
611 try:
611 try:
612 filename = get_py_filename(parameter_s)
612 filename = get_py_filename(parameter_s)
613 except IOError,msg:
613 except IOError,msg:
614 print msg
614 print msg
615 return
615 return
616 page.page(self.shell.inspector.format(file(filename).read()))
616 page.page(self.shell.inspector.format(open(filename).read()))
617
617
618 def magic_psearch(self, parameter_s=''):
618 def magic_psearch(self, parameter_s=''):
619 """Search for object in namespaces by wildcard.
619 """Search for object in namespaces by wildcard.
620
620
621 %psearch [options] PATTERN [OBJECT TYPE]
621 %psearch [options] PATTERN [OBJECT TYPE]
622
622
623 Note: ? can be used as a synonym for %psearch, at the beginning or at
623 Note: ? can be used as a synonym for %psearch, at the beginning or at
624 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
624 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
625 rest of the command line must be unchanged (options come first), so
625 rest of the command line must be unchanged (options come first), so
626 for example the following forms are equivalent
626 for example the following forms are equivalent
627
627
628 %psearch -i a* function
628 %psearch -i a* function
629 -i a* function?
629 -i a* function?
630 ?-i a* function
630 ?-i a* function
631
631
632 Arguments:
632 Arguments:
633
633
634 PATTERN
634 PATTERN
635
635
636 where PATTERN is a string containing * as a wildcard similar to its
636 where PATTERN is a string containing * as a wildcard similar to its
637 use in a shell. The pattern is matched in all namespaces on the
637 use in a shell. The pattern is matched in all namespaces on the
638 search path. By default objects starting with a single _ are not
638 search path. By default objects starting with a single _ are not
639 matched, many IPython generated objects have a single
639 matched, many IPython generated objects have a single
640 underscore. The default is case insensitive matching. Matching is
640 underscore. The default is case insensitive matching. Matching is
641 also done on the attributes of objects and not only on the objects
641 also done on the attributes of objects and not only on the objects
642 in a module.
642 in a module.
643
643
644 [OBJECT TYPE]
644 [OBJECT TYPE]
645
645
646 Is the name of a python type from the types module. The name is
646 Is the name of a python type from the types module. The name is
647 given in lowercase without the ending type, ex. StringType is
647 given in lowercase without the ending type, ex. StringType is
648 written string. By adding a type here only objects matching the
648 written string. By adding a type here only objects matching the
649 given type are matched. Using all here makes the pattern match all
649 given type are matched. Using all here makes the pattern match all
650 types (this is the default).
650 types (this is the default).
651
651
652 Options:
652 Options:
653
653
654 -a: makes the pattern match even objects whose names start with a
654 -a: makes the pattern match even objects whose names start with a
655 single underscore. These names are normally omitted from the
655 single underscore. These names are normally omitted from the
656 search.
656 search.
657
657
658 -i/-c: make the pattern case insensitive/sensitive. If neither of
658 -i/-c: make the pattern case insensitive/sensitive. If neither of
659 these options are given, the default is read from your configuration
659 these options are given, the default is read from your configuration
660 file, with the option ``InteractiveShell.wildcards_case_sensitive``.
660 file, with the option ``InteractiveShell.wildcards_case_sensitive``.
661 If this option is not specified in your configuration file, IPython's
661 If this option is not specified in your configuration file, IPython's
662 internal default is to do a case sensitive search.
662 internal default is to do a case sensitive search.
663
663
664 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
664 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
665 specify can be searched in any of the following namespaces:
665 specify can be searched in any of the following namespaces:
666 'builtin', 'user', 'user_global','internal', 'alias', where
666 'builtin', 'user', 'user_global','internal', 'alias', where
667 'builtin' and 'user' are the search defaults. Note that you should
667 'builtin' and 'user' are the search defaults. Note that you should
668 not use quotes when specifying namespaces.
668 not use quotes when specifying namespaces.
669
669
670 'Builtin' contains the python module builtin, 'user' contains all
670 'Builtin' contains the python module builtin, 'user' contains all
671 user data, 'alias' only contain the shell aliases and no python
671 user data, 'alias' only contain the shell aliases and no python
672 objects, 'internal' contains objects used by IPython. The
672 objects, 'internal' contains objects used by IPython. The
673 'user_global' namespace is only used by embedded IPython instances,
673 'user_global' namespace is only used by embedded IPython instances,
674 and it contains module-level globals. You can add namespaces to the
674 and it contains module-level globals. You can add namespaces to the
675 search with -s or exclude them with -e (these options can be given
675 search with -s or exclude them with -e (these options can be given
676 more than once).
676 more than once).
677
677
678 Examples
678 Examples
679 --------
679 --------
680 ::
680 ::
681
681
682 %psearch a* -> objects beginning with an a
682 %psearch a* -> objects beginning with an a
683 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
683 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
684 %psearch a* function -> all functions beginning with an a
684 %psearch a* function -> all functions beginning with an a
685 %psearch re.e* -> objects beginning with an e in module re
685 %psearch re.e* -> objects beginning with an e in module re
686 %psearch r*.e* -> objects that start with e in modules starting in r
686 %psearch r*.e* -> objects that start with e in modules starting in r
687 %psearch r*.* string -> all strings in modules beginning with r
687 %psearch r*.* string -> all strings in modules beginning with r
688
688
689 Case sensitive search::
689 Case sensitive search::
690
690
691 %psearch -c a* list all object beginning with lower case a
691 %psearch -c a* list all object beginning with lower case a
692
692
693 Show objects beginning with a single _::
693 Show objects beginning with a single _::
694
694
695 %psearch -a _* list objects beginning with a single underscore"""
695 %psearch -a _* list objects beginning with a single underscore"""
696 try:
696 try:
697 parameter_s.encode('ascii')
697 parameter_s.encode('ascii')
698 except UnicodeEncodeError:
698 except UnicodeEncodeError:
699 print 'Python identifiers can only contain ascii characters.'
699 print 'Python identifiers can only contain ascii characters.'
700 return
700 return
701
701
702 # default namespaces to be searched
702 # default namespaces to be searched
703 def_search = ['user_local', 'user_global', 'builtin']
703 def_search = ['user_local', 'user_global', 'builtin']
704
704
705 # Process options/args
705 # Process options/args
706 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
706 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
707 opt = opts.get
707 opt = opts.get
708 shell = self.shell
708 shell = self.shell
709 psearch = shell.inspector.psearch
709 psearch = shell.inspector.psearch
710
710
711 # select case options
711 # select case options
712 if opts.has_key('i'):
712 if opts.has_key('i'):
713 ignore_case = True
713 ignore_case = True
714 elif opts.has_key('c'):
714 elif opts.has_key('c'):
715 ignore_case = False
715 ignore_case = False
716 else:
716 else:
717 ignore_case = not shell.wildcards_case_sensitive
717 ignore_case = not shell.wildcards_case_sensitive
718
718
719 # Build list of namespaces to search from user options
719 # Build list of namespaces to search from user options
720 def_search.extend(opt('s',[]))
720 def_search.extend(opt('s',[]))
721 ns_exclude = ns_exclude=opt('e',[])
721 ns_exclude = ns_exclude=opt('e',[])
722 ns_search = [nm for nm in def_search if nm not in ns_exclude]
722 ns_search = [nm for nm in def_search if nm not in ns_exclude]
723
723
724 # Call the actual search
724 # Call the actual search
725 try:
725 try:
726 psearch(args,shell.ns_table,ns_search,
726 psearch(args,shell.ns_table,ns_search,
727 show_all=opt('a'),ignore_case=ignore_case)
727 show_all=opt('a'),ignore_case=ignore_case)
728 except:
728 except:
729 shell.showtraceback()
729 shell.showtraceback()
730
730
731 @skip_doctest
731 @skip_doctest
732 def magic_who_ls(self, parameter_s=''):
732 def magic_who_ls(self, parameter_s=''):
733 """Return a sorted list of all interactive variables.
733 """Return a sorted list of all interactive variables.
734
734
735 If arguments are given, only variables of types matching these
735 If arguments are given, only variables of types matching these
736 arguments are returned.
736 arguments are returned.
737
737
738 Examples
738 Examples
739 --------
739 --------
740
740
741 Define two variables and list them with who_ls::
741 Define two variables and list them with who_ls::
742
742
743 In [1]: alpha = 123
743 In [1]: alpha = 123
744
744
745 In [2]: beta = 'test'
745 In [2]: beta = 'test'
746
746
747 In [3]: %who_ls
747 In [3]: %who_ls
748 Out[3]: ['alpha', 'beta']
748 Out[3]: ['alpha', 'beta']
749
749
750 In [4]: %who_ls int
750 In [4]: %who_ls int
751 Out[4]: ['alpha']
751 Out[4]: ['alpha']
752
752
753 In [5]: %who_ls str
753 In [5]: %who_ls str
754 Out[5]: ['beta']
754 Out[5]: ['beta']
755 """
755 """
756
756
757 user_ns = self.shell.user_ns
757 user_ns = self.shell.user_ns
758 user_ns_hidden = self.shell.user_ns_hidden
758 user_ns_hidden = self.shell.user_ns_hidden
759 out = [ i for i in user_ns
759 out = [ i for i in user_ns
760 if not i.startswith('_') \
760 if not i.startswith('_') \
761 and not i in user_ns_hidden ]
761 and not i in user_ns_hidden ]
762
762
763 typelist = parameter_s.split()
763 typelist = parameter_s.split()
764 if typelist:
764 if typelist:
765 typeset = set(typelist)
765 typeset = set(typelist)
766 out = [i for i in out if type(user_ns[i]).__name__ in typeset]
766 out = [i for i in out if type(user_ns[i]).__name__ in typeset]
767
767
768 out.sort()
768 out.sort()
769 return out
769 return out
770
770
771 @skip_doctest
771 @skip_doctest
772 def magic_who(self, parameter_s=''):
772 def magic_who(self, parameter_s=''):
773 """Print all interactive variables, with some minimal formatting.
773 """Print all interactive variables, with some minimal formatting.
774
774
775 If any arguments are given, only variables whose type matches one of
775 If any arguments are given, only variables whose type matches one of
776 these are printed. For example::
776 these are printed. For example::
777
777
778 %who function str
778 %who function str
779
779
780 will only list functions and strings, excluding all other types of
780 will only list functions and strings, excluding all other types of
781 variables. To find the proper type names, simply use type(var) at a
781 variables. To find the proper type names, simply use type(var) at a
782 command line to see how python prints type names. For example:
782 command line to see how python prints type names. For example:
783
783
784 ::
784 ::
785
785
786 In [1]: type('hello')\\
786 In [1]: type('hello')\\
787 Out[1]: <type 'str'>
787 Out[1]: <type 'str'>
788
788
789 indicates that the type name for strings is 'str'.
789 indicates that the type name for strings is 'str'.
790
790
791 ``%who`` always excludes executed names loaded through your configuration
791 ``%who`` always excludes executed names loaded through your configuration
792 file and things which are internal to IPython.
792 file and things which are internal to IPython.
793
793
794 This is deliberate, as typically you may load many modules and the
794 This is deliberate, as typically you may load many modules and the
795 purpose of %who is to show you only what you've manually defined.
795 purpose of %who is to show you only what you've manually defined.
796
796
797 Examples
797 Examples
798 --------
798 --------
799
799
800 Define two variables and list them with who::
800 Define two variables and list them with who::
801
801
802 In [1]: alpha = 123
802 In [1]: alpha = 123
803
803
804 In [2]: beta = 'test'
804 In [2]: beta = 'test'
805
805
806 In [3]: %who
806 In [3]: %who
807 alpha beta
807 alpha beta
808
808
809 In [4]: %who int
809 In [4]: %who int
810 alpha
810 alpha
811
811
812 In [5]: %who str
812 In [5]: %who str
813 beta
813 beta
814 """
814 """
815
815
816 varlist = self.magic_who_ls(parameter_s)
816 varlist = self.magic_who_ls(parameter_s)
817 if not varlist:
817 if not varlist:
818 if parameter_s:
818 if parameter_s:
819 print 'No variables match your requested type.'
819 print 'No variables match your requested type.'
820 else:
820 else:
821 print 'Interactive namespace is empty.'
821 print 'Interactive namespace is empty.'
822 return
822 return
823
823
824 # if we have variables, move on...
824 # if we have variables, move on...
825 count = 0
825 count = 0
826 for i in varlist:
826 for i in varlist:
827 print i+'\t',
827 print i+'\t',
828 count += 1
828 count += 1
829 if count > 8:
829 if count > 8:
830 count = 0
830 count = 0
831 print
831 print
832 print
832 print
833
833
834 @skip_doctest
834 @skip_doctest
835 def magic_whos(self, parameter_s=''):
835 def magic_whos(self, parameter_s=''):
836 """Like %who, but gives some extra information about each variable.
836 """Like %who, but gives some extra information about each variable.
837
837
838 The same type filtering of %who can be applied here.
838 The same type filtering of %who can be applied here.
839
839
840 For all variables, the type is printed. Additionally it prints:
840 For all variables, the type is printed. Additionally it prints:
841
841
842 - For {},[],(): their length.
842 - For {},[],(): their length.
843
843
844 - For numpy arrays, a summary with shape, number of
844 - For numpy arrays, a summary with shape, number of
845 elements, typecode and size in memory.
845 elements, typecode and size in memory.
846
846
847 - Everything else: a string representation, snipping their middle if
847 - Everything else: a string representation, snipping their middle if
848 too long.
848 too long.
849
849
850 Examples
850 Examples
851 --------
851 --------
852
852
853 Define two variables and list them with whos::
853 Define two variables and list them with whos::
854
854
855 In [1]: alpha = 123
855 In [1]: alpha = 123
856
856
857 In [2]: beta = 'test'
857 In [2]: beta = 'test'
858
858
859 In [3]: %whos
859 In [3]: %whos
860 Variable Type Data/Info
860 Variable Type Data/Info
861 --------------------------------
861 --------------------------------
862 alpha int 123
862 alpha int 123
863 beta str test
863 beta str test
864 """
864 """
865
865
866 varnames = self.magic_who_ls(parameter_s)
866 varnames = self.magic_who_ls(parameter_s)
867 if not varnames:
867 if not varnames:
868 if parameter_s:
868 if parameter_s:
869 print 'No variables match your requested type.'
869 print 'No variables match your requested type.'
870 else:
870 else:
871 print 'Interactive namespace is empty.'
871 print 'Interactive namespace is empty.'
872 return
872 return
873
873
874 # if we have variables, move on...
874 # if we have variables, move on...
875
875
876 # for these types, show len() instead of data:
876 # for these types, show len() instead of data:
877 seq_types = ['dict', 'list', 'tuple']
877 seq_types = ['dict', 'list', 'tuple']
878
878
879 # for numpy arrays, display summary info
879 # for numpy arrays, display summary info
880 ndarray_type = None
880 ndarray_type = None
881 if 'numpy' in sys.modules:
881 if 'numpy' in sys.modules:
882 try:
882 try:
883 from numpy import ndarray
883 from numpy import ndarray
884 except ImportError:
884 except ImportError:
885 pass
885 pass
886 else:
886 else:
887 ndarray_type = ndarray.__name__
887 ndarray_type = ndarray.__name__
888
888
889 # Find all variable names and types so we can figure out column sizes
889 # Find all variable names and types so we can figure out column sizes
890 def get_vars(i):
890 def get_vars(i):
891 return self.shell.user_ns[i]
891 return self.shell.user_ns[i]
892
892
893 # some types are well known and can be shorter
893 # some types are well known and can be shorter
894 abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
894 abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
895 def type_name(v):
895 def type_name(v):
896 tn = type(v).__name__
896 tn = type(v).__name__
897 return abbrevs.get(tn,tn)
897 return abbrevs.get(tn,tn)
898
898
899 varlist = map(get_vars,varnames)
899 varlist = map(get_vars,varnames)
900
900
901 typelist = []
901 typelist = []
902 for vv in varlist:
902 for vv in varlist:
903 tt = type_name(vv)
903 tt = type_name(vv)
904
904
905 if tt=='instance':
905 if tt=='instance':
906 typelist.append( abbrevs.get(str(vv.__class__),
906 typelist.append( abbrevs.get(str(vv.__class__),
907 str(vv.__class__)))
907 str(vv.__class__)))
908 else:
908 else:
909 typelist.append(tt)
909 typelist.append(tt)
910
910
911 # column labels and # of spaces as separator
911 # column labels and # of spaces as separator
912 varlabel = 'Variable'
912 varlabel = 'Variable'
913 typelabel = 'Type'
913 typelabel = 'Type'
914 datalabel = 'Data/Info'
914 datalabel = 'Data/Info'
915 colsep = 3
915 colsep = 3
916 # variable format strings
916 # variable format strings
917 vformat = "{0:<{varwidth}}{1:<{typewidth}}"
917 vformat = "{0:<{varwidth}}{1:<{typewidth}}"
918 aformat = "%s: %s elems, type `%s`, %s bytes"
918 aformat = "%s: %s elems, type `%s`, %s bytes"
919 # find the size of the columns to format the output nicely
919 # find the size of the columns to format the output nicely
920 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
920 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
921 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
921 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
922 # table header
922 # table header
923 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
923 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
924 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
924 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
925 # and the table itself
925 # and the table itself
926 kb = 1024
926 kb = 1024
927 Mb = 1048576 # kb**2
927 Mb = 1048576 # kb**2
928 for vname,var,vtype in zip(varnames,varlist,typelist):
928 for vname,var,vtype in zip(varnames,varlist,typelist):
929 print vformat.format(vname, vtype, varwidth=varwidth, typewidth=typewidth),
929 print vformat.format(vname, vtype, varwidth=varwidth, typewidth=typewidth),
930 if vtype in seq_types:
930 if vtype in seq_types:
931 print "n="+str(len(var))
931 print "n="+str(len(var))
932 elif vtype == ndarray_type:
932 elif vtype == ndarray_type:
933 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
933 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
934 if vtype==ndarray_type:
934 if vtype==ndarray_type:
935 # numpy
935 # numpy
936 vsize = var.size
936 vsize = var.size
937 vbytes = vsize*var.itemsize
937 vbytes = vsize*var.itemsize
938 vdtype = var.dtype
938 vdtype = var.dtype
939
939
940 if vbytes < 100000:
940 if vbytes < 100000:
941 print aformat % (vshape,vsize,vdtype,vbytes)
941 print aformat % (vshape,vsize,vdtype,vbytes)
942 else:
942 else:
943 print aformat % (vshape,vsize,vdtype,vbytes),
943 print aformat % (vshape,vsize,vdtype,vbytes),
944 if vbytes < Mb:
944 if vbytes < Mb:
945 print '(%s kb)' % (vbytes/kb,)
945 print '(%s kb)' % (vbytes/kb,)
946 else:
946 else:
947 print '(%s Mb)' % (vbytes/Mb,)
947 print '(%s Mb)' % (vbytes/Mb,)
948 else:
948 else:
949 try:
949 try:
950 vstr = str(var)
950 vstr = str(var)
951 except UnicodeEncodeError:
951 except UnicodeEncodeError:
952 vstr = unicode(var).encode(sys.getdefaultencoding(),
952 vstr = unicode(var).encode(sys.getdefaultencoding(),
953 'backslashreplace')
953 'backslashreplace')
954 vstr = vstr.replace('\n','\\n')
954 vstr = vstr.replace('\n','\\n')
955 if len(vstr) < 50:
955 if len(vstr) < 50:
956 print vstr
956 print vstr
957 else:
957 else:
958 print vstr[:25] + "<...>" + vstr[-25:]
958 print vstr[:25] + "<...>" + vstr[-25:]
959
959
960 def magic_reset(self, parameter_s=''):
960 def magic_reset(self, parameter_s=''):
961 """Resets the namespace by removing all names defined by the user, if
961 """Resets the namespace by removing all names defined by the user, if
962 called without arguments, or by removing some types of objects, such
962 called without arguments, or by removing some types of objects, such
963 as everything currently in IPython's In[] and Out[] containers (see
963 as everything currently in IPython's In[] and Out[] containers (see
964 the parameters for details).
964 the parameters for details).
965
965
966 Parameters
966 Parameters
967 ----------
967 ----------
968 -f : force reset without asking for confirmation.
968 -f : force reset without asking for confirmation.
969
969
970 -s : 'Soft' reset: Only clears your namespace, leaving history intact.
970 -s : 'Soft' reset: Only clears your namespace, leaving history intact.
971 References to objects may be kept. By default (without this option),
971 References to objects may be kept. By default (without this option),
972 we do a 'hard' reset, giving you a new session and removing all
972 we do a 'hard' reset, giving you a new session and removing all
973 references to objects from the current session.
973 references to objects from the current session.
974
974
975 in : reset input history
975 in : reset input history
976
976
977 out : reset output history
977 out : reset output history
978
978
979 dhist : reset directory history
979 dhist : reset directory history
980
980
981 array : reset only variables that are NumPy arrays
981 array : reset only variables that are NumPy arrays
982
982
983 See Also
983 See Also
984 --------
984 --------
985 magic_reset_selective : invoked as ``%reset_selective``
985 magic_reset_selective : invoked as ``%reset_selective``
986
986
987 Examples
987 Examples
988 --------
988 --------
989 ::
989 ::
990
990
991 In [6]: a = 1
991 In [6]: a = 1
992
992
993 In [7]: a
993 In [7]: a
994 Out[7]: 1
994 Out[7]: 1
995
995
996 In [8]: 'a' in _ip.user_ns
996 In [8]: 'a' in _ip.user_ns
997 Out[8]: True
997 Out[8]: True
998
998
999 In [9]: %reset -f
999 In [9]: %reset -f
1000
1000
1001 In [1]: 'a' in _ip.user_ns
1001 In [1]: 'a' in _ip.user_ns
1002 Out[1]: False
1002 Out[1]: False
1003
1003
1004 In [2]: %reset -f in
1004 In [2]: %reset -f in
1005 Flushing input history
1005 Flushing input history
1006
1006
1007 In [3]: %reset -f dhist in
1007 In [3]: %reset -f dhist in
1008 Flushing directory history
1008 Flushing directory history
1009 Flushing input history
1009 Flushing input history
1010
1010
1011 Notes
1011 Notes
1012 -----
1012 -----
1013 Calling this magic from clients that do not implement standard input,
1013 Calling this magic from clients that do not implement standard input,
1014 such as the ipython notebook interface, will reset the namespace
1014 such as the ipython notebook interface, will reset the namespace
1015 without confirmation.
1015 without confirmation.
1016 """
1016 """
1017 opts, args = self.parse_options(parameter_s,'sf', mode='list')
1017 opts, args = self.parse_options(parameter_s,'sf', mode='list')
1018 if 'f' in opts:
1018 if 'f' in opts:
1019 ans = True
1019 ans = True
1020 else:
1020 else:
1021 try:
1021 try:
1022 ans = self.shell.ask_yes_no(
1022 ans = self.shell.ask_yes_no(
1023 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ", default='n')
1023 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ", default='n')
1024 except StdinNotImplementedError:
1024 except StdinNotImplementedError:
1025 ans = True
1025 ans = True
1026 if not ans:
1026 if not ans:
1027 print 'Nothing done.'
1027 print 'Nothing done.'
1028 return
1028 return
1029
1029
1030 if 's' in opts: # Soft reset
1030 if 's' in opts: # Soft reset
1031 user_ns = self.shell.user_ns
1031 user_ns = self.shell.user_ns
1032 for i in self.magic_who_ls():
1032 for i in self.magic_who_ls():
1033 del(user_ns[i])
1033 del(user_ns[i])
1034 elif len(args) == 0: # Hard reset
1034 elif len(args) == 0: # Hard reset
1035 self.shell.reset(new_session = False)
1035 self.shell.reset(new_session = False)
1036
1036
1037 # reset in/out/dhist/array: previously extensinions/clearcmd.py
1037 # reset in/out/dhist/array: previously extensinions/clearcmd.py
1038 ip = self.shell
1038 ip = self.shell
1039 user_ns = self.user_ns # local lookup, heavily used
1039 user_ns = self.user_ns # local lookup, heavily used
1040
1040
1041 for target in args:
1041 for target in args:
1042 target = target.lower() # make matches case insensitive
1042 target = target.lower() # make matches case insensitive
1043 if target == 'out':
1043 if target == 'out':
1044 print "Flushing output cache (%d entries)" % len(user_ns['_oh'])
1044 print "Flushing output cache (%d entries)" % len(user_ns['_oh'])
1045 self.displayhook.flush()
1045 self.displayhook.flush()
1046
1046
1047 elif target == 'in':
1047 elif target == 'in':
1048 print "Flushing input history"
1048 print "Flushing input history"
1049 pc = self.displayhook.prompt_count + 1
1049 pc = self.displayhook.prompt_count + 1
1050 for n in range(1, pc):
1050 for n in range(1, pc):
1051 key = '_i'+repr(n)
1051 key = '_i'+repr(n)
1052 user_ns.pop(key,None)
1052 user_ns.pop(key,None)
1053 user_ns.update(dict(_i=u'',_ii=u'',_iii=u''))
1053 user_ns.update(dict(_i=u'',_ii=u'',_iii=u''))
1054 hm = ip.history_manager
1054 hm = ip.history_manager
1055 # don't delete these, as %save and %macro depending on the length
1055 # don't delete these, as %save and %macro depending on the length
1056 # of these lists to be preserved
1056 # of these lists to be preserved
1057 hm.input_hist_parsed[:] = [''] * pc
1057 hm.input_hist_parsed[:] = [''] * pc
1058 hm.input_hist_raw[:] = [''] * pc
1058 hm.input_hist_raw[:] = [''] * pc
1059 # hm has internal machinery for _i,_ii,_iii, clear it out
1059 # hm has internal machinery for _i,_ii,_iii, clear it out
1060 hm._i = hm._ii = hm._iii = hm._i00 = u''
1060 hm._i = hm._ii = hm._iii = hm._i00 = u''
1061
1061
1062 elif target == 'array':
1062 elif target == 'array':
1063 # Support cleaning up numpy arrays
1063 # Support cleaning up numpy arrays
1064 try:
1064 try:
1065 from numpy import ndarray
1065 from numpy import ndarray
1066 # This must be done with items and not iteritems because we're
1066 # This must be done with items and not iteritems because we're
1067 # going to modify the dict in-place.
1067 # going to modify the dict in-place.
1068 for x,val in user_ns.items():
1068 for x,val in user_ns.items():
1069 if isinstance(val,ndarray):
1069 if isinstance(val,ndarray):
1070 del user_ns[x]
1070 del user_ns[x]
1071 except ImportError:
1071 except ImportError:
1072 print "reset array only works if Numpy is available."
1072 print "reset array only works if Numpy is available."
1073
1073
1074 elif target == 'dhist':
1074 elif target == 'dhist':
1075 print "Flushing directory history"
1075 print "Flushing directory history"
1076 del user_ns['_dh'][:]
1076 del user_ns['_dh'][:]
1077
1077
1078 else:
1078 else:
1079 print "Don't know how to reset ",
1079 print "Don't know how to reset ",
1080 print target + ", please run `%reset?` for details"
1080 print target + ", please run `%reset?` for details"
1081
1081
1082 gc.collect()
1082 gc.collect()
1083
1083
1084 def magic_reset_selective(self, parameter_s=''):
1084 def magic_reset_selective(self, parameter_s=''):
1085 """Resets the namespace by removing names defined by the user.
1085 """Resets the namespace by removing names defined by the user.
1086
1086
1087 Input/Output history are left around in case you need them.
1087 Input/Output history are left around in case you need them.
1088
1088
1089 %reset_selective [-f] regex
1089 %reset_selective [-f] regex
1090
1090
1091 No action is taken if regex is not included
1091 No action is taken if regex is not included
1092
1092
1093 Options
1093 Options
1094 -f : force reset without asking for confirmation.
1094 -f : force reset without asking for confirmation.
1095
1095
1096 See Also
1096 See Also
1097 --------
1097 --------
1098 magic_reset : invoked as ``%reset``
1098 magic_reset : invoked as ``%reset``
1099
1099
1100 Examples
1100 Examples
1101 --------
1101 --------
1102
1102
1103 We first fully reset the namespace so your output looks identical to
1103 We first fully reset the namespace so your output looks identical to
1104 this example for pedagogical reasons; in practice you do not need a
1104 this example for pedagogical reasons; in practice you do not need a
1105 full reset::
1105 full reset::
1106
1106
1107 In [1]: %reset -f
1107 In [1]: %reset -f
1108
1108
1109 Now, with a clean namespace we can make a few variables and use
1109 Now, with a clean namespace we can make a few variables and use
1110 ``%reset_selective`` to only delete names that match our regexp::
1110 ``%reset_selective`` to only delete names that match our regexp::
1111
1111
1112 In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
1112 In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
1113
1113
1114 In [3]: who_ls
1114 In [3]: who_ls
1115 Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
1115 Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
1116
1116
1117 In [4]: %reset_selective -f b[2-3]m
1117 In [4]: %reset_selective -f b[2-3]m
1118
1118
1119 In [5]: who_ls
1119 In [5]: who_ls
1120 Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
1120 Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
1121
1121
1122 In [6]: %reset_selective -f d
1122 In [6]: %reset_selective -f d
1123
1123
1124 In [7]: who_ls
1124 In [7]: who_ls
1125 Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
1125 Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
1126
1126
1127 In [8]: %reset_selective -f c
1127 In [8]: %reset_selective -f c
1128
1128
1129 In [9]: who_ls
1129 In [9]: who_ls
1130 Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
1130 Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
1131
1131
1132 In [10]: %reset_selective -f b
1132 In [10]: %reset_selective -f b
1133
1133
1134 In [11]: who_ls
1134 In [11]: who_ls
1135 Out[11]: ['a']
1135 Out[11]: ['a']
1136
1136
1137 Notes
1137 Notes
1138 -----
1138 -----
1139 Calling this magic from clients that do not implement standard input,
1139 Calling this magic from clients that do not implement standard input,
1140 such as the ipython notebook interface, will reset the namespace
1140 such as the ipython notebook interface, will reset the namespace
1141 without confirmation.
1141 without confirmation.
1142 """
1142 """
1143
1143
1144 opts, regex = self.parse_options(parameter_s,'f')
1144 opts, regex = self.parse_options(parameter_s,'f')
1145
1145
1146 if opts.has_key('f'):
1146 if opts.has_key('f'):
1147 ans = True
1147 ans = True
1148 else:
1148 else:
1149 try:
1149 try:
1150 ans = self.shell.ask_yes_no(
1150 ans = self.shell.ask_yes_no(
1151 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ",
1151 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ",
1152 default='n')
1152 default='n')
1153 except StdinNotImplementedError:
1153 except StdinNotImplementedError:
1154 ans = True
1154 ans = True
1155 if not ans:
1155 if not ans:
1156 print 'Nothing done.'
1156 print 'Nothing done.'
1157 return
1157 return
1158 user_ns = self.shell.user_ns
1158 user_ns = self.shell.user_ns
1159 if not regex:
1159 if not regex:
1160 print 'No regex pattern specified. Nothing done.'
1160 print 'No regex pattern specified. Nothing done.'
1161 return
1161 return
1162 else:
1162 else:
1163 try:
1163 try:
1164 m = re.compile(regex)
1164 m = re.compile(regex)
1165 except TypeError:
1165 except TypeError:
1166 raise TypeError('regex must be a string or compiled pattern')
1166 raise TypeError('regex must be a string or compiled pattern')
1167 for i in self.magic_who_ls():
1167 for i in self.magic_who_ls():
1168 if m.search(i):
1168 if m.search(i):
1169 del(user_ns[i])
1169 del(user_ns[i])
1170
1170
1171 def magic_xdel(self, parameter_s=''):
1171 def magic_xdel(self, parameter_s=''):
1172 """Delete a variable, trying to clear it from anywhere that
1172 """Delete a variable, trying to clear it from anywhere that
1173 IPython's machinery has references to it. By default, this uses
1173 IPython's machinery has references to it. By default, this uses
1174 the identity of the named object in the user namespace to remove
1174 the identity of the named object in the user namespace to remove
1175 references held under other names. The object is also removed
1175 references held under other names. The object is also removed
1176 from the output history.
1176 from the output history.
1177
1177
1178 Options
1178 Options
1179 -n : Delete the specified name from all namespaces, without
1179 -n : Delete the specified name from all namespaces, without
1180 checking their identity.
1180 checking their identity.
1181 """
1181 """
1182 opts, varname = self.parse_options(parameter_s,'n')
1182 opts, varname = self.parse_options(parameter_s,'n')
1183 try:
1183 try:
1184 self.shell.del_var(varname, ('n' in opts))
1184 self.shell.del_var(varname, ('n' in opts))
1185 except (NameError, ValueError) as e:
1185 except (NameError, ValueError) as e:
1186 print type(e).__name__ +": "+ str(e)
1186 print type(e).__name__ +": "+ str(e)
1187
1187
1188 def magic_logstart(self,parameter_s=''):
1188 def magic_logstart(self,parameter_s=''):
1189 """Start logging anywhere in a session.
1189 """Start logging anywhere in a session.
1190
1190
1191 %logstart [-o|-r|-t] [log_name [log_mode]]
1191 %logstart [-o|-r|-t] [log_name [log_mode]]
1192
1192
1193 If no name is given, it defaults to a file named 'ipython_log.py' in your
1193 If no name is given, it defaults to a file named 'ipython_log.py' in your
1194 current directory, in 'rotate' mode (see below).
1194 current directory, in 'rotate' mode (see below).
1195
1195
1196 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1196 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1197 history up to that point and then continues logging.
1197 history up to that point and then continues logging.
1198
1198
1199 %logstart takes a second optional parameter: logging mode. This can be one
1199 %logstart takes a second optional parameter: logging mode. This can be one
1200 of (note that the modes are given unquoted):\\
1200 of (note that the modes are given unquoted):\\
1201 append: well, that says it.\\
1201 append: well, that says it.\\
1202 backup: rename (if exists) to name~ and start name.\\
1202 backup: rename (if exists) to name~ and start name.\\
1203 global: single logfile in your home dir, appended to.\\
1203 global: single logfile in your home dir, appended to.\\
1204 over : overwrite existing log.\\
1204 over : overwrite existing log.\\
1205 rotate: create rotating logs name.1~, name.2~, etc.
1205 rotate: create rotating logs name.1~, name.2~, etc.
1206
1206
1207 Options:
1207 Options:
1208
1208
1209 -o: log also IPython's output. In this mode, all commands which
1209 -o: log also IPython's output. In this mode, all commands which
1210 generate an Out[NN] prompt are recorded to the logfile, right after
1210 generate an Out[NN] prompt are recorded to the logfile, right after
1211 their corresponding input line. The output lines are always
1211 their corresponding input line. The output lines are always
1212 prepended with a '#[Out]# ' marker, so that the log remains valid
1212 prepended with a '#[Out]# ' marker, so that the log remains valid
1213 Python code.
1213 Python code.
1214
1214
1215 Since this marker is always the same, filtering only the output from
1215 Since this marker is always the same, filtering only the output from
1216 a log is very easy, using for example a simple awk call::
1216 a log is very easy, using for example a simple awk call::
1217
1217
1218 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1218 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1219
1219
1220 -r: log 'raw' input. Normally, IPython's logs contain the processed
1220 -r: log 'raw' input. Normally, IPython's logs contain the processed
1221 input, so that user lines are logged in their final form, converted
1221 input, so that user lines are logged in their final form, converted
1222 into valid Python. For example, %Exit is logged as
1222 into valid Python. For example, %Exit is logged as
1223 _ip.magic("Exit"). If the -r flag is given, all input is logged
1223 _ip.magic("Exit"). If the -r flag is given, all input is logged
1224 exactly as typed, with no transformations applied.
1224 exactly as typed, with no transformations applied.
1225
1225
1226 -t: put timestamps before each input line logged (these are put in
1226 -t: put timestamps before each input line logged (these are put in
1227 comments)."""
1227 comments)."""
1228
1228
1229 opts,par = self.parse_options(parameter_s,'ort')
1229 opts,par = self.parse_options(parameter_s,'ort')
1230 log_output = 'o' in opts
1230 log_output = 'o' in opts
1231 log_raw_input = 'r' in opts
1231 log_raw_input = 'r' in opts
1232 timestamp = 't' in opts
1232 timestamp = 't' in opts
1233
1233
1234 logger = self.shell.logger
1234 logger = self.shell.logger
1235
1235
1236 # if no args are given, the defaults set in the logger constructor by
1236 # if no args are given, the defaults set in the logger constructor by
1237 # ipython remain valid
1237 # ipython remain valid
1238 if par:
1238 if par:
1239 try:
1239 try:
1240 logfname,logmode = par.split()
1240 logfname,logmode = par.split()
1241 except:
1241 except:
1242 logfname = par
1242 logfname = par
1243 logmode = 'backup'
1243 logmode = 'backup'
1244 else:
1244 else:
1245 logfname = logger.logfname
1245 logfname = logger.logfname
1246 logmode = logger.logmode
1246 logmode = logger.logmode
1247 # put logfname into rc struct as if it had been called on the command
1247 # put logfname into rc struct as if it had been called on the command
1248 # line, so it ends up saved in the log header Save it in case we need
1248 # line, so it ends up saved in the log header Save it in case we need
1249 # to restore it...
1249 # to restore it...
1250 old_logfile = self.shell.logfile
1250 old_logfile = self.shell.logfile
1251 if logfname:
1251 if logfname:
1252 logfname = os.path.expanduser(logfname)
1252 logfname = os.path.expanduser(logfname)
1253 self.shell.logfile = logfname
1253 self.shell.logfile = logfname
1254
1254
1255 loghead = '# IPython log file\n\n'
1255 loghead = '# IPython log file\n\n'
1256 try:
1256 try:
1257 started = logger.logstart(logfname,loghead,logmode,
1257 started = logger.logstart(logfname,loghead,logmode,
1258 log_output,timestamp,log_raw_input)
1258 log_output,timestamp,log_raw_input)
1259 except:
1259 except:
1260 self.shell.logfile = old_logfile
1260 self.shell.logfile = old_logfile
1261 warn("Couldn't start log: %s" % sys.exc_info()[1])
1261 warn("Couldn't start log: %s" % sys.exc_info()[1])
1262 else:
1262 else:
1263 # log input history up to this point, optionally interleaving
1263 # log input history up to this point, optionally interleaving
1264 # output if requested
1264 # output if requested
1265
1265
1266 if timestamp:
1266 if timestamp:
1267 # disable timestamping for the previous history, since we've
1267 # disable timestamping for the previous history, since we've
1268 # lost those already (no time machine here).
1268 # lost those already (no time machine here).
1269 logger.timestamp = False
1269 logger.timestamp = False
1270
1270
1271 if log_raw_input:
1271 if log_raw_input:
1272 input_hist = self.shell.history_manager.input_hist_raw
1272 input_hist = self.shell.history_manager.input_hist_raw
1273 else:
1273 else:
1274 input_hist = self.shell.history_manager.input_hist_parsed
1274 input_hist = self.shell.history_manager.input_hist_parsed
1275
1275
1276 if log_output:
1276 if log_output:
1277 log_write = logger.log_write
1277 log_write = logger.log_write
1278 output_hist = self.shell.history_manager.output_hist
1278 output_hist = self.shell.history_manager.output_hist
1279 for n in range(1,len(input_hist)-1):
1279 for n in range(1,len(input_hist)-1):
1280 log_write(input_hist[n].rstrip() + '\n')
1280 log_write(input_hist[n].rstrip() + '\n')
1281 if n in output_hist:
1281 if n in output_hist:
1282 log_write(repr(output_hist[n]),'output')
1282 log_write(repr(output_hist[n]),'output')
1283 else:
1283 else:
1284 logger.log_write('\n'.join(input_hist[1:]))
1284 logger.log_write('\n'.join(input_hist[1:]))
1285 logger.log_write('\n')
1285 logger.log_write('\n')
1286 if timestamp:
1286 if timestamp:
1287 # re-enable timestamping
1287 # re-enable timestamping
1288 logger.timestamp = True
1288 logger.timestamp = True
1289
1289
1290 print ('Activating auto-logging. '
1290 print ('Activating auto-logging. '
1291 'Current session state plus future input saved.')
1291 'Current session state plus future input saved.')
1292 logger.logstate()
1292 logger.logstate()
1293
1293
1294 def magic_logstop(self,parameter_s=''):
1294 def magic_logstop(self,parameter_s=''):
1295 """Fully stop logging and close log file.
1295 """Fully stop logging and close log file.
1296
1296
1297 In order to start logging again, a new %logstart call needs to be made,
1297 In order to start logging again, a new %logstart call needs to be made,
1298 possibly (though not necessarily) with a new filename, mode and other
1298 possibly (though not necessarily) with a new filename, mode and other
1299 options."""
1299 options."""
1300 self.logger.logstop()
1300 self.logger.logstop()
1301
1301
1302 def magic_logoff(self,parameter_s=''):
1302 def magic_logoff(self,parameter_s=''):
1303 """Temporarily stop logging.
1303 """Temporarily stop logging.
1304
1304
1305 You must have previously started logging."""
1305 You must have previously started logging."""
1306 self.shell.logger.switch_log(0)
1306 self.shell.logger.switch_log(0)
1307
1307
1308 def magic_logon(self,parameter_s=''):
1308 def magic_logon(self,parameter_s=''):
1309 """Restart logging.
1309 """Restart logging.
1310
1310
1311 This function is for restarting logging which you've temporarily
1311 This function is for restarting logging which you've temporarily
1312 stopped with %logoff. For starting logging for the first time, you
1312 stopped with %logoff. For starting logging for the first time, you
1313 must use the %logstart function, which allows you to specify an
1313 must use the %logstart function, which allows you to specify an
1314 optional log filename."""
1314 optional log filename."""
1315
1315
1316 self.shell.logger.switch_log(1)
1316 self.shell.logger.switch_log(1)
1317
1317
1318 def magic_logstate(self,parameter_s=''):
1318 def magic_logstate(self,parameter_s=''):
1319 """Print the status of the logging system."""
1319 """Print the status of the logging system."""
1320
1320
1321 self.shell.logger.logstate()
1321 self.shell.logger.logstate()
1322
1322
1323 def magic_pdb(self, parameter_s=''):
1323 def magic_pdb(self, parameter_s=''):
1324 """Control the automatic calling of the pdb interactive debugger.
1324 """Control the automatic calling of the pdb interactive debugger.
1325
1325
1326 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1326 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1327 argument it works as a toggle.
1327 argument it works as a toggle.
1328
1328
1329 When an exception is triggered, IPython can optionally call the
1329 When an exception is triggered, IPython can optionally call the
1330 interactive pdb debugger after the traceback printout. %pdb toggles
1330 interactive pdb debugger after the traceback printout. %pdb toggles
1331 this feature on and off.
1331 this feature on and off.
1332
1332
1333 The initial state of this feature is set in your configuration
1333 The initial state of this feature is set in your configuration
1334 file (the option is ``InteractiveShell.pdb``).
1334 file (the option is ``InteractiveShell.pdb``).
1335
1335
1336 If you want to just activate the debugger AFTER an exception has fired,
1336 If you want to just activate the debugger AFTER an exception has fired,
1337 without having to type '%pdb on' and rerunning your code, you can use
1337 without having to type '%pdb on' and rerunning your code, you can use
1338 the %debug magic."""
1338 the %debug magic."""
1339
1339
1340 par = parameter_s.strip().lower()
1340 par = parameter_s.strip().lower()
1341
1341
1342 if par:
1342 if par:
1343 try:
1343 try:
1344 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1344 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1345 except KeyError:
1345 except KeyError:
1346 print ('Incorrect argument. Use on/1, off/0, '
1346 print ('Incorrect argument. Use on/1, off/0, '
1347 'or nothing for a toggle.')
1347 'or nothing for a toggle.')
1348 return
1348 return
1349 else:
1349 else:
1350 # toggle
1350 # toggle
1351 new_pdb = not self.shell.call_pdb
1351 new_pdb = not self.shell.call_pdb
1352
1352
1353 # set on the shell
1353 # set on the shell
1354 self.shell.call_pdb = new_pdb
1354 self.shell.call_pdb = new_pdb
1355 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1355 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1356
1356
1357 def magic_debug(self, parameter_s=''):
1357 def magic_debug(self, parameter_s=''):
1358 """Activate the interactive debugger in post-mortem mode.
1358 """Activate the interactive debugger in post-mortem mode.
1359
1359
1360 If an exception has just occurred, this lets you inspect its stack
1360 If an exception has just occurred, this lets you inspect its stack
1361 frames interactively. Note that this will always work only on the last
1361 frames interactively. Note that this will always work only on the last
1362 traceback that occurred, so you must call this quickly after an
1362 traceback that occurred, so you must call this quickly after an
1363 exception that you wish to inspect has fired, because if another one
1363 exception that you wish to inspect has fired, because if another one
1364 occurs, it clobbers the previous one.
1364 occurs, it clobbers the previous one.
1365
1365
1366 If you want IPython to automatically do this on every exception, see
1366 If you want IPython to automatically do this on every exception, see
1367 the %pdb magic for more details.
1367 the %pdb magic for more details.
1368 """
1368 """
1369 self.shell.debugger(force=True)
1369 self.shell.debugger(force=True)
1370
1370
1371 @skip_doctest
1371 @skip_doctest
1372 def magic_prun(self, parameter_s ='',user_mode=1,
1372 def magic_prun(self, parameter_s ='',user_mode=1,
1373 opts=None,arg_lst=None,prog_ns=None):
1373 opts=None,arg_lst=None,prog_ns=None):
1374
1374
1375 """Run a statement through the python code profiler.
1375 """Run a statement through the python code profiler.
1376
1376
1377 Usage:
1377 Usage:
1378 %prun [options] statement
1378 %prun [options] statement
1379
1379
1380 The given statement (which doesn't require quote marks) is run via the
1380 The given statement (which doesn't require quote marks) is run via the
1381 python profiler in a manner similar to the profile.run() function.
1381 python profiler in a manner similar to the profile.run() function.
1382 Namespaces are internally managed to work correctly; profile.run
1382 Namespaces are internally managed to work correctly; profile.run
1383 cannot be used in IPython because it makes certain assumptions about
1383 cannot be used in IPython because it makes certain assumptions about
1384 namespaces which do not hold under IPython.
1384 namespaces which do not hold under IPython.
1385
1385
1386 Options:
1386 Options:
1387
1387
1388 -l <limit>: you can place restrictions on what or how much of the
1388 -l <limit>: you can place restrictions on what or how much of the
1389 profile gets printed. The limit value can be:
1389 profile gets printed. The limit value can be:
1390
1390
1391 * A string: only information for function names containing this string
1391 * A string: only information for function names containing this string
1392 is printed.
1392 is printed.
1393
1393
1394 * An integer: only these many lines are printed.
1394 * An integer: only these many lines are printed.
1395
1395
1396 * A float (between 0 and 1): this fraction of the report is printed
1396 * A float (between 0 and 1): this fraction of the report is printed
1397 (for example, use a limit of 0.4 to see the topmost 40% only).
1397 (for example, use a limit of 0.4 to see the topmost 40% only).
1398
1398
1399 You can combine several limits with repeated use of the option. For
1399 You can combine several limits with repeated use of the option. For
1400 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1400 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1401 information about class constructors.
1401 information about class constructors.
1402
1402
1403 -r: return the pstats.Stats object generated by the profiling. This
1403 -r: return the pstats.Stats object generated by the profiling. This
1404 object has all the information about the profile in it, and you can
1404 object has all the information about the profile in it, and you can
1405 later use it for further analysis or in other functions.
1405 later use it for further analysis or in other functions.
1406
1406
1407 -s <key>: sort profile by given key. You can provide more than one key
1407 -s <key>: sort profile by given key. You can provide more than one key
1408 by using the option several times: '-s key1 -s key2 -s key3...'. The
1408 by using the option several times: '-s key1 -s key2 -s key3...'. The
1409 default sorting key is 'time'.
1409 default sorting key is 'time'.
1410
1410
1411 The following is copied verbatim from the profile documentation
1411 The following is copied verbatim from the profile documentation
1412 referenced below:
1412 referenced below:
1413
1413
1414 When more than one key is provided, additional keys are used as
1414 When more than one key is provided, additional keys are used as
1415 secondary criteria when the there is equality in all keys selected
1415 secondary criteria when the there is equality in all keys selected
1416 before them.
1416 before them.
1417
1417
1418 Abbreviations can be used for any key names, as long as the
1418 Abbreviations can be used for any key names, as long as the
1419 abbreviation is unambiguous. The following are the keys currently
1419 abbreviation is unambiguous. The following are the keys currently
1420 defined:
1420 defined:
1421
1421
1422 Valid Arg Meaning
1422 Valid Arg Meaning
1423 "calls" call count
1423 "calls" call count
1424 "cumulative" cumulative time
1424 "cumulative" cumulative time
1425 "file" file name
1425 "file" file name
1426 "module" file name
1426 "module" file name
1427 "pcalls" primitive call count
1427 "pcalls" primitive call count
1428 "line" line number
1428 "line" line number
1429 "name" function name
1429 "name" function name
1430 "nfl" name/file/line
1430 "nfl" name/file/line
1431 "stdname" standard name
1431 "stdname" standard name
1432 "time" internal time
1432 "time" internal time
1433
1433
1434 Note that all sorts on statistics are in descending order (placing
1434 Note that all sorts on statistics are in descending order (placing
1435 most time consuming items first), where as name, file, and line number
1435 most time consuming items first), where as name, file, and line number
1436 searches are in ascending order (i.e., alphabetical). The subtle
1436 searches are in ascending order (i.e., alphabetical). The subtle
1437 distinction between "nfl" and "stdname" is that the standard name is a
1437 distinction between "nfl" and "stdname" is that the standard name is a
1438 sort of the name as printed, which means that the embedded line
1438 sort of the name as printed, which means that the embedded line
1439 numbers get compared in an odd way. For example, lines 3, 20, and 40
1439 numbers get compared in an odd way. For example, lines 3, 20, and 40
1440 would (if the file names were the same) appear in the string order
1440 would (if the file names were the same) appear in the string order
1441 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1441 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1442 line numbers. In fact, sort_stats("nfl") is the same as
1442 line numbers. In fact, sort_stats("nfl") is the same as
1443 sort_stats("name", "file", "line").
1443 sort_stats("name", "file", "line").
1444
1444
1445 -T <filename>: save profile results as shown on screen to a text
1445 -T <filename>: save profile results as shown on screen to a text
1446 file. The profile is still shown on screen.
1446 file. The profile is still shown on screen.
1447
1447
1448 -D <filename>: save (via dump_stats) profile statistics to given
1448 -D <filename>: save (via dump_stats) profile statistics to given
1449 filename. This data is in a format understood by the pstats module, and
1449 filename. This data is in a format understood by the pstats module, and
1450 is generated by a call to the dump_stats() method of profile
1450 is generated by a call to the dump_stats() method of profile
1451 objects. The profile is still shown on screen.
1451 objects. The profile is still shown on screen.
1452
1452
1453 -q: suppress output to the pager. Best used with -T and/or -D above.
1453 -q: suppress output to the pager. Best used with -T and/or -D above.
1454
1454
1455 If you want to run complete programs under the profiler's control, use
1455 If you want to run complete programs under the profiler's control, use
1456 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1456 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1457 contains profiler specific options as described here.
1457 contains profiler specific options as described here.
1458
1458
1459 You can read the complete documentation for the profile module with::
1459 You can read the complete documentation for the profile module with::
1460
1460
1461 In [1]: import profile; profile.help()
1461 In [1]: import profile; profile.help()
1462 """
1462 """
1463
1463
1464 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1464 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1465
1465
1466 if user_mode: # regular user call
1466 if user_mode: # regular user call
1467 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:q',
1467 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:q',
1468 list_all=1, posix=False)
1468 list_all=1, posix=False)
1469 namespace = self.shell.user_ns
1469 namespace = self.shell.user_ns
1470 else: # called to run a program by %run -p
1470 else: # called to run a program by %run -p
1471 try:
1471 try:
1472 filename = get_py_filename(arg_lst[0])
1472 filename = get_py_filename(arg_lst[0])
1473 except IOError as e:
1473 except IOError as e:
1474 try:
1474 try:
1475 msg = str(e)
1475 msg = str(e)
1476 except UnicodeError:
1476 except UnicodeError:
1477 msg = e.message
1477 msg = e.message
1478 error(msg)
1478 error(msg)
1479 return
1479 return
1480
1480
1481 arg_str = 'execfile(filename,prog_ns)'
1481 arg_str = 'execfile(filename,prog_ns)'
1482 namespace = {
1482 namespace = {
1483 'execfile': self.shell.safe_execfile,
1483 'execfile': self.shell.safe_execfile,
1484 'prog_ns': prog_ns,
1484 'prog_ns': prog_ns,
1485 'filename': filename
1485 'filename': filename
1486 }
1486 }
1487
1487
1488 opts.merge(opts_def)
1488 opts.merge(opts_def)
1489
1489
1490 prof = profile.Profile()
1490 prof = profile.Profile()
1491 try:
1491 try:
1492 prof = prof.runctx(arg_str,namespace,namespace)
1492 prof = prof.runctx(arg_str,namespace,namespace)
1493 sys_exit = ''
1493 sys_exit = ''
1494 except SystemExit:
1494 except SystemExit:
1495 sys_exit = """*** SystemExit exception caught in code being profiled."""
1495 sys_exit = """*** SystemExit exception caught in code being profiled."""
1496
1496
1497 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1497 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1498
1498
1499 lims = opts.l
1499 lims = opts.l
1500 if lims:
1500 if lims:
1501 lims = [] # rebuild lims with ints/floats/strings
1501 lims = [] # rebuild lims with ints/floats/strings
1502 for lim in opts.l:
1502 for lim in opts.l:
1503 try:
1503 try:
1504 lims.append(int(lim))
1504 lims.append(int(lim))
1505 except ValueError:
1505 except ValueError:
1506 try:
1506 try:
1507 lims.append(float(lim))
1507 lims.append(float(lim))
1508 except ValueError:
1508 except ValueError:
1509 lims.append(lim)
1509 lims.append(lim)
1510
1510
1511 # Trap output.
1511 # Trap output.
1512 stdout_trap = StringIO()
1512 stdout_trap = StringIO()
1513
1513
1514 if hasattr(stats,'stream'):
1514 if hasattr(stats,'stream'):
1515 # In newer versions of python, the stats object has a 'stream'
1515 # In newer versions of python, the stats object has a 'stream'
1516 # attribute to write into.
1516 # attribute to write into.
1517 stats.stream = stdout_trap
1517 stats.stream = stdout_trap
1518 stats.print_stats(*lims)
1518 stats.print_stats(*lims)
1519 else:
1519 else:
1520 # For older versions, we manually redirect stdout during printing
1520 # For older versions, we manually redirect stdout during printing
1521 sys_stdout = sys.stdout
1521 sys_stdout = sys.stdout
1522 try:
1522 try:
1523 sys.stdout = stdout_trap
1523 sys.stdout = stdout_trap
1524 stats.print_stats(*lims)
1524 stats.print_stats(*lims)
1525 finally:
1525 finally:
1526 sys.stdout = sys_stdout
1526 sys.stdout = sys_stdout
1527
1527
1528 output = stdout_trap.getvalue()
1528 output = stdout_trap.getvalue()
1529 output = output.rstrip()
1529 output = output.rstrip()
1530
1530
1531 if 'q' not in opts:
1531 if 'q' not in opts:
1532 page.page(output)
1532 page.page(output)
1533 print sys_exit,
1533 print sys_exit,
1534
1534
1535 dump_file = opts.D[0]
1535 dump_file = opts.D[0]
1536 text_file = opts.T[0]
1536 text_file = opts.T[0]
1537 if dump_file:
1537 if dump_file:
1538 dump_file = unquote_filename(dump_file)
1538 dump_file = unquote_filename(dump_file)
1539 prof.dump_stats(dump_file)
1539 prof.dump_stats(dump_file)
1540 print '\n*** Profile stats marshalled to file',\
1540 print '\n*** Profile stats marshalled to file',\
1541 `dump_file`+'.',sys_exit
1541 `dump_file`+'.',sys_exit
1542 if text_file:
1542 if text_file:
1543 text_file = unquote_filename(text_file)
1543 text_file = unquote_filename(text_file)
1544 pfile = file(text_file,'w')
1544 pfile = open(text_file,'w')
1545 pfile.write(output)
1545 pfile.write(output)
1546 pfile.close()
1546 pfile.close()
1547 print '\n*** Profile printout saved to text file',\
1547 print '\n*** Profile printout saved to text file',\
1548 `text_file`+'.',sys_exit
1548 `text_file`+'.',sys_exit
1549
1549
1550 if opts.has_key('r'):
1550 if opts.has_key('r'):
1551 return stats
1551 return stats
1552 else:
1552 else:
1553 return None
1553 return None
1554
1554
1555 @skip_doctest
1555 @skip_doctest
1556 def magic_run(self, parameter_s ='', runner=None,
1556 def magic_run(self, parameter_s ='', runner=None,
1557 file_finder=get_py_filename):
1557 file_finder=get_py_filename):
1558 """Run the named file inside IPython as a program.
1558 """Run the named file inside IPython as a program.
1559
1559
1560 Usage:\\
1560 Usage:\\
1561 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1561 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1562
1562
1563 Parameters after the filename are passed as command-line arguments to
1563 Parameters after the filename are passed as command-line arguments to
1564 the program (put in sys.argv). Then, control returns to IPython's
1564 the program (put in sys.argv). Then, control returns to IPython's
1565 prompt.
1565 prompt.
1566
1566
1567 This is similar to running at a system prompt:\\
1567 This is similar to running at a system prompt:\\
1568 $ python file args\\
1568 $ python file args\\
1569 but with the advantage of giving you IPython's tracebacks, and of
1569 but with the advantage of giving you IPython's tracebacks, and of
1570 loading all variables into your interactive namespace for further use
1570 loading all variables into your interactive namespace for further use
1571 (unless -p is used, see below).
1571 (unless -p is used, see below).
1572
1572
1573 The file is executed in a namespace initially consisting only of
1573 The file is executed in a namespace initially consisting only of
1574 __name__=='__main__' and sys.argv constructed as indicated. It thus
1574 __name__=='__main__' and sys.argv constructed as indicated. It thus
1575 sees its environment as if it were being run as a stand-alone program
1575 sees its environment as if it were being run as a stand-alone program
1576 (except for sharing global objects such as previously imported
1576 (except for sharing global objects such as previously imported
1577 modules). But after execution, the IPython interactive namespace gets
1577 modules). But after execution, the IPython interactive namespace gets
1578 updated with all variables defined in the program (except for __name__
1578 updated with all variables defined in the program (except for __name__
1579 and sys.argv). This allows for very convenient loading of code for
1579 and sys.argv). This allows for very convenient loading of code for
1580 interactive work, while giving each program a 'clean sheet' to run in.
1580 interactive work, while giving each program a 'clean sheet' to run in.
1581
1581
1582 Options:
1582 Options:
1583
1583
1584 -n: __name__ is NOT set to '__main__', but to the running file's name
1584 -n: __name__ is NOT set to '__main__', but to the running file's name
1585 without extension (as python does under import). This allows running
1585 without extension (as python does under import). This allows running
1586 scripts and reloading the definitions in them without calling code
1586 scripts and reloading the definitions in them without calling code
1587 protected by an ' if __name__ == "__main__" ' clause.
1587 protected by an ' if __name__ == "__main__" ' clause.
1588
1588
1589 -i: run the file in IPython's namespace instead of an empty one. This
1589 -i: run the file in IPython's namespace instead of an empty one. This
1590 is useful if you are experimenting with code written in a text editor
1590 is useful if you are experimenting with code written in a text editor
1591 which depends on variables defined interactively.
1591 which depends on variables defined interactively.
1592
1592
1593 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1593 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1594 being run. This is particularly useful if IPython is being used to
1594 being run. This is particularly useful if IPython is being used to
1595 run unittests, which always exit with a sys.exit() call. In such
1595 run unittests, which always exit with a sys.exit() call. In such
1596 cases you are interested in the output of the test results, not in
1596 cases you are interested in the output of the test results, not in
1597 seeing a traceback of the unittest module.
1597 seeing a traceback of the unittest module.
1598
1598
1599 -t: print timing information at the end of the run. IPython will give
1599 -t: print timing information at the end of the run. IPython will give
1600 you an estimated CPU time consumption for your script, which under
1600 you an estimated CPU time consumption for your script, which under
1601 Unix uses the resource module to avoid the wraparound problems of
1601 Unix uses the resource module to avoid the wraparound problems of
1602 time.clock(). Under Unix, an estimate of time spent on system tasks
1602 time.clock(). Under Unix, an estimate of time spent on system tasks
1603 is also given (for Windows platforms this is reported as 0.0).
1603 is also given (for Windows platforms this is reported as 0.0).
1604
1604
1605 If -t is given, an additional -N<N> option can be given, where <N>
1605 If -t is given, an additional -N<N> option can be given, where <N>
1606 must be an integer indicating how many times you want the script to
1606 must be an integer indicating how many times you want the script to
1607 run. The final timing report will include total and per run results.
1607 run. The final timing report will include total and per run results.
1608
1608
1609 For example (testing the script uniq_stable.py)::
1609 For example (testing the script uniq_stable.py)::
1610
1610
1611 In [1]: run -t uniq_stable
1611 In [1]: run -t uniq_stable
1612
1612
1613 IPython CPU timings (estimated):\\
1613 IPython CPU timings (estimated):\\
1614 User : 0.19597 s.\\
1614 User : 0.19597 s.\\
1615 System: 0.0 s.\\
1615 System: 0.0 s.\\
1616
1616
1617 In [2]: run -t -N5 uniq_stable
1617 In [2]: run -t -N5 uniq_stable
1618
1618
1619 IPython CPU timings (estimated):\\
1619 IPython CPU timings (estimated):\\
1620 Total runs performed: 5\\
1620 Total runs performed: 5\\
1621 Times : Total Per run\\
1621 Times : Total Per run\\
1622 User : 0.910862 s, 0.1821724 s.\\
1622 User : 0.910862 s, 0.1821724 s.\\
1623 System: 0.0 s, 0.0 s.
1623 System: 0.0 s, 0.0 s.
1624
1624
1625 -d: run your program under the control of pdb, the Python debugger.
1625 -d: run your program under the control of pdb, the Python debugger.
1626 This allows you to execute your program step by step, watch variables,
1626 This allows you to execute your program step by step, watch variables,
1627 etc. Internally, what IPython does is similar to calling:
1627 etc. Internally, what IPython does is similar to calling:
1628
1628
1629 pdb.run('execfile("YOURFILENAME")')
1629 pdb.run('execfile("YOURFILENAME")')
1630
1630
1631 with a breakpoint set on line 1 of your file. You can change the line
1631 with a breakpoint set on line 1 of your file. You can change the line
1632 number for this automatic breakpoint to be <N> by using the -bN option
1632 number for this automatic breakpoint to be <N> by using the -bN option
1633 (where N must be an integer). For example::
1633 (where N must be an integer). For example::
1634
1634
1635 %run -d -b40 myscript
1635 %run -d -b40 myscript
1636
1636
1637 will set the first breakpoint at line 40 in myscript.py. Note that
1637 will set the first breakpoint at line 40 in myscript.py. Note that
1638 the first breakpoint must be set on a line which actually does
1638 the first breakpoint must be set on a line which actually does
1639 something (not a comment or docstring) for it to stop execution.
1639 something (not a comment or docstring) for it to stop execution.
1640
1640
1641 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1641 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1642 first enter 'c' (without quotes) to start execution up to the first
1642 first enter 'c' (without quotes) to start execution up to the first
1643 breakpoint.
1643 breakpoint.
1644
1644
1645 Entering 'help' gives information about the use of the debugger. You
1645 Entering 'help' gives information about the use of the debugger. You
1646 can easily see pdb's full documentation with "import pdb;pdb.help()"
1646 can easily see pdb's full documentation with "import pdb;pdb.help()"
1647 at a prompt.
1647 at a prompt.
1648
1648
1649 -p: run program under the control of the Python profiler module (which
1649 -p: run program under the control of the Python profiler module (which
1650 prints a detailed report of execution times, function calls, etc).
1650 prints a detailed report of execution times, function calls, etc).
1651
1651
1652 You can pass other options after -p which affect the behavior of the
1652 You can pass other options after -p which affect the behavior of the
1653 profiler itself. See the docs for %prun for details.
1653 profiler itself. See the docs for %prun for details.
1654
1654
1655 In this mode, the program's variables do NOT propagate back to the
1655 In this mode, the program's variables do NOT propagate back to the
1656 IPython interactive namespace (because they remain in the namespace
1656 IPython interactive namespace (because they remain in the namespace
1657 where the profiler executes them).
1657 where the profiler executes them).
1658
1658
1659 Internally this triggers a call to %prun, see its documentation for
1659 Internally this triggers a call to %prun, see its documentation for
1660 details on the options available specifically for profiling.
1660 details on the options available specifically for profiling.
1661
1661
1662 There is one special usage for which the text above doesn't apply:
1662 There is one special usage for which the text above doesn't apply:
1663 if the filename ends with .ipy, the file is run as ipython script,
1663 if the filename ends with .ipy, the file is run as ipython script,
1664 just as if the commands were written on IPython prompt.
1664 just as if the commands were written on IPython prompt.
1665
1665
1666 -m: specify module name to load instead of script path. Similar to
1666 -m: specify module name to load instead of script path. Similar to
1667 the -m option for the python interpreter. Use this option last if you
1667 the -m option for the python interpreter. Use this option last if you
1668 want to combine with other %run options. Unlike the python interpreter
1668 want to combine with other %run options. Unlike the python interpreter
1669 only source modules are allowed no .pyc or .pyo files.
1669 only source modules are allowed no .pyc or .pyo files.
1670 For example::
1670 For example::
1671
1671
1672 %run -m example
1672 %run -m example
1673
1673
1674 will run the example module.
1674 will run the example module.
1675
1675
1676 """
1676 """
1677
1677
1678 # get arguments and set sys.argv for program to be run.
1678 # get arguments and set sys.argv for program to be run.
1679 opts, arg_lst = self.parse_options(parameter_s, 'nidtN:b:pD:l:rs:T:em:',
1679 opts, arg_lst = self.parse_options(parameter_s, 'nidtN:b:pD:l:rs:T:em:',
1680 mode='list', list_all=1)
1680 mode='list', list_all=1)
1681 if "m" in opts:
1681 if "m" in opts:
1682 modulename = opts["m"][0]
1682 modulename = opts["m"][0]
1683 modpath = find_mod(modulename)
1683 modpath = find_mod(modulename)
1684 if modpath is None:
1684 if modpath is None:
1685 warn('%r is not a valid modulename on sys.path'%modulename)
1685 warn('%r is not a valid modulename on sys.path'%modulename)
1686 return
1686 return
1687 arg_lst = [modpath] + arg_lst
1687 arg_lst = [modpath] + arg_lst
1688 try:
1688 try:
1689 filename = file_finder(arg_lst[0])
1689 filename = file_finder(arg_lst[0])
1690 except IndexError:
1690 except IndexError:
1691 warn('you must provide at least a filename.')
1691 warn('you must provide at least a filename.')
1692 print '\n%run:\n', oinspect.getdoc(self.magic_run)
1692 print '\n%run:\n', oinspect.getdoc(self.magic_run)
1693 return
1693 return
1694 except IOError as e:
1694 except IOError as e:
1695 try:
1695 try:
1696 msg = str(e)
1696 msg = str(e)
1697 except UnicodeError:
1697 except UnicodeError:
1698 msg = e.message
1698 msg = e.message
1699 error(msg)
1699 error(msg)
1700 return
1700 return
1701
1701
1702 if filename.lower().endswith('.ipy'):
1702 if filename.lower().endswith('.ipy'):
1703 self.shell.safe_execfile_ipy(filename)
1703 self.shell.safe_execfile_ipy(filename)
1704 return
1704 return
1705
1705
1706 # Control the response to exit() calls made by the script being run
1706 # Control the response to exit() calls made by the script being run
1707 exit_ignore = 'e' in opts
1707 exit_ignore = 'e' in opts
1708
1708
1709 # Make sure that the running script gets a proper sys.argv as if it
1709 # Make sure that the running script gets a proper sys.argv as if it
1710 # were run from a system shell.
1710 # were run from a system shell.
1711 save_argv = sys.argv # save it for later restoring
1711 save_argv = sys.argv # save it for later restoring
1712
1712
1713 # simulate shell expansion on arguments, at least tilde expansion
1713 # simulate shell expansion on arguments, at least tilde expansion
1714 args = [ os.path.expanduser(a) for a in arg_lst[1:] ]
1714 args = [ os.path.expanduser(a) for a in arg_lst[1:] ]
1715
1715
1716 sys.argv = [filename] + args # put in the proper filename
1716 sys.argv = [filename] + args # put in the proper filename
1717 # protect sys.argv from potential unicode strings on Python 2:
1717 # protect sys.argv from potential unicode strings on Python 2:
1718 if not py3compat.PY3:
1718 if not py3compat.PY3:
1719 sys.argv = [ py3compat.cast_bytes(a) for a in sys.argv ]
1719 sys.argv = [ py3compat.cast_bytes(a) for a in sys.argv ]
1720
1720
1721 if 'i' in opts:
1721 if 'i' in opts:
1722 # Run in user's interactive namespace
1722 # Run in user's interactive namespace
1723 prog_ns = self.shell.user_ns
1723 prog_ns = self.shell.user_ns
1724 __name__save = self.shell.user_ns['__name__']
1724 __name__save = self.shell.user_ns['__name__']
1725 prog_ns['__name__'] = '__main__'
1725 prog_ns['__name__'] = '__main__'
1726 main_mod = self.shell.new_main_mod(prog_ns)
1726 main_mod = self.shell.new_main_mod(prog_ns)
1727 else:
1727 else:
1728 # Run in a fresh, empty namespace
1728 # Run in a fresh, empty namespace
1729 if 'n' in opts:
1729 if 'n' in opts:
1730 name = os.path.splitext(os.path.basename(filename))[0]
1730 name = os.path.splitext(os.path.basename(filename))[0]
1731 else:
1731 else:
1732 name = '__main__'
1732 name = '__main__'
1733
1733
1734 main_mod = self.shell.new_main_mod()
1734 main_mod = self.shell.new_main_mod()
1735 prog_ns = main_mod.__dict__
1735 prog_ns = main_mod.__dict__
1736 prog_ns['__name__'] = name
1736 prog_ns['__name__'] = name
1737
1737
1738 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1738 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1739 # set the __file__ global in the script's namespace
1739 # set the __file__ global in the script's namespace
1740 prog_ns['__file__'] = filename
1740 prog_ns['__file__'] = filename
1741
1741
1742 # pickle fix. See interactiveshell for an explanation. But we need to make sure
1742 # pickle fix. See interactiveshell for an explanation. But we need to make sure
1743 # that, if we overwrite __main__, we replace it at the end
1743 # that, if we overwrite __main__, we replace it at the end
1744 main_mod_name = prog_ns['__name__']
1744 main_mod_name = prog_ns['__name__']
1745
1745
1746 if main_mod_name == '__main__':
1746 if main_mod_name == '__main__':
1747 restore_main = sys.modules['__main__']
1747 restore_main = sys.modules['__main__']
1748 else:
1748 else:
1749 restore_main = False
1749 restore_main = False
1750
1750
1751 # This needs to be undone at the end to prevent holding references to
1751 # This needs to be undone at the end to prevent holding references to
1752 # every single object ever created.
1752 # every single object ever created.
1753 sys.modules[main_mod_name] = main_mod
1753 sys.modules[main_mod_name] = main_mod
1754
1754
1755 try:
1755 try:
1756 stats = None
1756 stats = None
1757 with self.readline_no_record:
1757 with self.readline_no_record:
1758 if 'p' in opts:
1758 if 'p' in opts:
1759 stats = self.magic_prun('', 0, opts, arg_lst, prog_ns)
1759 stats = self.magic_prun('', 0, opts, arg_lst, prog_ns)
1760 else:
1760 else:
1761 if 'd' in opts:
1761 if 'd' in opts:
1762 deb = debugger.Pdb(self.shell.colors)
1762 deb = debugger.Pdb(self.shell.colors)
1763 # reset Breakpoint state, which is moronically kept
1763 # reset Breakpoint state, which is moronically kept
1764 # in a class
1764 # in a class
1765 bdb.Breakpoint.next = 1
1765 bdb.Breakpoint.next = 1
1766 bdb.Breakpoint.bplist = {}
1766 bdb.Breakpoint.bplist = {}
1767 bdb.Breakpoint.bpbynumber = [None]
1767 bdb.Breakpoint.bpbynumber = [None]
1768 # Set an initial breakpoint to stop execution
1768 # Set an initial breakpoint to stop execution
1769 maxtries = 10
1769 maxtries = 10
1770 bp = int(opts.get('b', [1])[0])
1770 bp = int(opts.get('b', [1])[0])
1771 checkline = deb.checkline(filename, bp)
1771 checkline = deb.checkline(filename, bp)
1772 if not checkline:
1772 if not checkline:
1773 for bp in range(bp + 1, bp + maxtries + 1):
1773 for bp in range(bp + 1, bp + maxtries + 1):
1774 if deb.checkline(filename, bp):
1774 if deb.checkline(filename, bp):
1775 break
1775 break
1776 else:
1776 else:
1777 msg = ("\nI failed to find a valid line to set "
1777 msg = ("\nI failed to find a valid line to set "
1778 "a breakpoint\n"
1778 "a breakpoint\n"
1779 "after trying up to line: %s.\n"
1779 "after trying up to line: %s.\n"
1780 "Please set a valid breakpoint manually "
1780 "Please set a valid breakpoint manually "
1781 "with the -b option." % bp)
1781 "with the -b option." % bp)
1782 error(msg)
1782 error(msg)
1783 return
1783 return
1784 # if we find a good linenumber, set the breakpoint
1784 # if we find a good linenumber, set the breakpoint
1785 deb.do_break('%s:%s' % (filename, bp))
1785 deb.do_break('%s:%s' % (filename, bp))
1786 # Start file run
1786 # Start file run
1787 print "NOTE: Enter 'c' at the",
1787 print "NOTE: Enter 'c' at the",
1788 print "%s prompt to start your script." % deb.prompt
1788 print "%s prompt to start your script." % deb.prompt
1789 ns = {'execfile': py3compat.execfile, 'prog_ns': prog_ns}
1789 ns = {'execfile': py3compat.execfile, 'prog_ns': prog_ns}
1790 try:
1790 try:
1791 deb.run('execfile("%s", prog_ns)' % filename, ns)
1791 deb.run('execfile("%s", prog_ns)' % filename, ns)
1792
1792
1793 except:
1793 except:
1794 etype, value, tb = sys.exc_info()
1794 etype, value, tb = sys.exc_info()
1795 # Skip three frames in the traceback: the %run one,
1795 # Skip three frames in the traceback: the %run one,
1796 # one inside bdb.py, and the command-line typed by the
1796 # one inside bdb.py, and the command-line typed by the
1797 # user (run by exec in pdb itself).
1797 # user (run by exec in pdb itself).
1798 self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
1798 self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
1799 else:
1799 else:
1800 if runner is None:
1800 if runner is None:
1801 runner = self.shell.safe_execfile
1801 runner = self.shell.safe_execfile
1802 if 't' in opts:
1802 if 't' in opts:
1803 # timed execution
1803 # timed execution
1804 try:
1804 try:
1805 nruns = int(opts['N'][0])
1805 nruns = int(opts['N'][0])
1806 if nruns < 1:
1806 if nruns < 1:
1807 error('Number of runs must be >=1')
1807 error('Number of runs must be >=1')
1808 return
1808 return
1809 except (KeyError):
1809 except (KeyError):
1810 nruns = 1
1810 nruns = 1
1811 twall0 = time.time()
1811 twall0 = time.time()
1812 if nruns == 1:
1812 if nruns == 1:
1813 t0 = clock2()
1813 t0 = clock2()
1814 runner(filename, prog_ns, prog_ns,
1814 runner(filename, prog_ns, prog_ns,
1815 exit_ignore=exit_ignore)
1815 exit_ignore=exit_ignore)
1816 t1 = clock2()
1816 t1 = clock2()
1817 t_usr = t1[0] - t0[0]
1817 t_usr = t1[0] - t0[0]
1818 t_sys = t1[1] - t0[1]
1818 t_sys = t1[1] - t0[1]
1819 print "\nIPython CPU timings (estimated):"
1819 print "\nIPython CPU timings (estimated):"
1820 print " User : %10.2f s." % t_usr
1820 print " User : %10.2f s." % t_usr
1821 print " System : %10.2f s." % t_sys
1821 print " System : %10.2f s." % t_sys
1822 else:
1822 else:
1823 runs = range(nruns)
1823 runs = range(nruns)
1824 t0 = clock2()
1824 t0 = clock2()
1825 for nr in runs:
1825 for nr in runs:
1826 runner(filename, prog_ns, prog_ns,
1826 runner(filename, prog_ns, prog_ns,
1827 exit_ignore=exit_ignore)
1827 exit_ignore=exit_ignore)
1828 t1 = clock2()
1828 t1 = clock2()
1829 t_usr = t1[0] - t0[0]
1829 t_usr = t1[0] - t0[0]
1830 t_sys = t1[1] - t0[1]
1830 t_sys = t1[1] - t0[1]
1831 print "\nIPython CPU timings (estimated):"
1831 print "\nIPython CPU timings (estimated):"
1832 print "Total runs performed:", nruns
1832 print "Total runs performed:", nruns
1833 print " Times : %10.2f %10.2f" % ('Total', 'Per run')
1833 print " Times : %10.2f %10.2f" % ('Total', 'Per run')
1834 print " User : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns)
1834 print " User : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns)
1835 print " System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns)
1835 print " System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns)
1836 twall1 = time.time()
1836 twall1 = time.time()
1837 print "Wall time: %10.2f s." % (twall1 - twall0)
1837 print "Wall time: %10.2f s." % (twall1 - twall0)
1838
1838
1839 else:
1839 else:
1840 # regular execution
1840 # regular execution
1841 runner(filename, prog_ns, prog_ns, exit_ignore=exit_ignore)
1841 runner(filename, prog_ns, prog_ns, exit_ignore=exit_ignore)
1842
1842
1843 if 'i' in opts:
1843 if 'i' in opts:
1844 self.shell.user_ns['__name__'] = __name__save
1844 self.shell.user_ns['__name__'] = __name__save
1845 else:
1845 else:
1846 # The shell MUST hold a reference to prog_ns so after %run
1846 # The shell MUST hold a reference to prog_ns so after %run
1847 # exits, the python deletion mechanism doesn't zero it out
1847 # exits, the python deletion mechanism doesn't zero it out
1848 # (leaving dangling references).
1848 # (leaving dangling references).
1849 self.shell.cache_main_mod(prog_ns, filename)
1849 self.shell.cache_main_mod(prog_ns, filename)
1850 # update IPython interactive namespace
1850 # update IPython interactive namespace
1851
1851
1852 # Some forms of read errors on the file may mean the
1852 # Some forms of read errors on the file may mean the
1853 # __name__ key was never set; using pop we don't have to
1853 # __name__ key was never set; using pop we don't have to
1854 # worry about a possible KeyError.
1854 # worry about a possible KeyError.
1855 prog_ns.pop('__name__', None)
1855 prog_ns.pop('__name__', None)
1856
1856
1857 self.shell.user_ns.update(prog_ns)
1857 self.shell.user_ns.update(prog_ns)
1858 finally:
1858 finally:
1859 # It's a bit of a mystery why, but __builtins__ can change from
1859 # It's a bit of a mystery why, but __builtins__ can change from
1860 # being a module to becoming a dict missing some key data after
1860 # being a module to becoming a dict missing some key data after
1861 # %run. As best I can see, this is NOT something IPython is doing
1861 # %run. As best I can see, this is NOT something IPython is doing
1862 # at all, and similar problems have been reported before:
1862 # at all, and similar problems have been reported before:
1863 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
1863 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
1864 # Since this seems to be done by the interpreter itself, the best
1864 # Since this seems to be done by the interpreter itself, the best
1865 # we can do is to at least restore __builtins__ for the user on
1865 # we can do is to at least restore __builtins__ for the user on
1866 # exit.
1866 # exit.
1867 self.shell.user_ns['__builtins__'] = builtin_mod
1867 self.shell.user_ns['__builtins__'] = builtin_mod
1868
1868
1869 # Ensure key global structures are restored
1869 # Ensure key global structures are restored
1870 sys.argv = save_argv
1870 sys.argv = save_argv
1871 if restore_main:
1871 if restore_main:
1872 sys.modules['__main__'] = restore_main
1872 sys.modules['__main__'] = restore_main
1873 else:
1873 else:
1874 # Remove from sys.modules the reference to main_mod we'd
1874 # Remove from sys.modules the reference to main_mod we'd
1875 # added. Otherwise it will trap references to objects
1875 # added. Otherwise it will trap references to objects
1876 # contained therein.
1876 # contained therein.
1877 del sys.modules[main_mod_name]
1877 del sys.modules[main_mod_name]
1878
1878
1879 return stats
1879 return stats
1880
1880
1881 @skip_doctest
1881 @skip_doctest
1882 def magic_timeit(self, parameter_s =''):
1882 def magic_timeit(self, parameter_s =''):
1883 """Time execution of a Python statement or expression
1883 """Time execution of a Python statement or expression
1884
1884
1885 Usage:\\
1885 Usage:\\
1886 %timeit [-n<N> -r<R> [-t|-c]] statement
1886 %timeit [-n<N> -r<R> [-t|-c]] statement
1887
1887
1888 Time execution of a Python statement or expression using the timeit
1888 Time execution of a Python statement or expression using the timeit
1889 module.
1889 module.
1890
1890
1891 Options:
1891 Options:
1892 -n<N>: execute the given statement <N> times in a loop. If this value
1892 -n<N>: execute the given statement <N> times in a loop. If this value
1893 is not given, a fitting value is chosen.
1893 is not given, a fitting value is chosen.
1894
1894
1895 -r<R>: repeat the loop iteration <R> times and take the best result.
1895 -r<R>: repeat the loop iteration <R> times and take the best result.
1896 Default: 3
1896 Default: 3
1897
1897
1898 -t: use time.time to measure the time, which is the default on Unix.
1898 -t: use time.time to measure the time, which is the default on Unix.
1899 This function measures wall time.
1899 This function measures wall time.
1900
1900
1901 -c: use time.clock to measure the time, which is the default on
1901 -c: use time.clock to measure the time, which is the default on
1902 Windows and measures wall time. On Unix, resource.getrusage is used
1902 Windows and measures wall time. On Unix, resource.getrusage is used
1903 instead and returns the CPU user time.
1903 instead and returns the CPU user time.
1904
1904
1905 -p<P>: use a precision of <P> digits to display the timing result.
1905 -p<P>: use a precision of <P> digits to display the timing result.
1906 Default: 3
1906 Default: 3
1907
1907
1908
1908
1909 Examples
1909 Examples
1910 --------
1910 --------
1911 ::
1911 ::
1912
1912
1913 In [1]: %timeit pass
1913 In [1]: %timeit pass
1914 10000000 loops, best of 3: 53.3 ns per loop
1914 10000000 loops, best of 3: 53.3 ns per loop
1915
1915
1916 In [2]: u = None
1916 In [2]: u = None
1917
1917
1918 In [3]: %timeit u is None
1918 In [3]: %timeit u is None
1919 10000000 loops, best of 3: 184 ns per loop
1919 10000000 loops, best of 3: 184 ns per loop
1920
1920
1921 In [4]: %timeit -r 4 u == None
1921 In [4]: %timeit -r 4 u == None
1922 1000000 loops, best of 4: 242 ns per loop
1922 1000000 loops, best of 4: 242 ns per loop
1923
1923
1924 In [5]: import time
1924 In [5]: import time
1925
1925
1926 In [6]: %timeit -n1 time.sleep(2)
1926 In [6]: %timeit -n1 time.sleep(2)
1927 1 loops, best of 3: 2 s per loop
1927 1 loops, best of 3: 2 s per loop
1928
1928
1929
1929
1930 The times reported by %timeit will be slightly higher than those
1930 The times reported by %timeit will be slightly higher than those
1931 reported by the timeit.py script when variables are accessed. This is
1931 reported by the timeit.py script when variables are accessed. This is
1932 due to the fact that %timeit executes the statement in the namespace
1932 due to the fact that %timeit executes the statement in the namespace
1933 of the shell, compared with timeit.py, which uses a single setup
1933 of the shell, compared with timeit.py, which uses a single setup
1934 statement to import function or create variables. Generally, the bias
1934 statement to import function or create variables. Generally, the bias
1935 does not matter as long as results from timeit.py are not mixed with
1935 does not matter as long as results from timeit.py are not mixed with
1936 those from %timeit."""
1936 those from %timeit."""
1937
1937
1938 import timeit
1938 import timeit
1939 import math
1939 import math
1940
1940
1941 # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
1941 # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
1942 # certain terminals. Until we figure out a robust way of
1942 # certain terminals. Until we figure out a robust way of
1943 # auto-detecting if the terminal can deal with it, use plain 'us' for
1943 # auto-detecting if the terminal can deal with it, use plain 'us' for
1944 # microseconds. I am really NOT happy about disabling the proper
1944 # microseconds. I am really NOT happy about disabling the proper
1945 # 'micro' prefix, but crashing is worse... If anyone knows what the
1945 # 'micro' prefix, but crashing is worse... If anyone knows what the
1946 # right solution for this is, I'm all ears...
1946 # right solution for this is, I'm all ears...
1947 #
1947 #
1948 # Note: using
1948 # Note: using
1949 #
1949 #
1950 # s = u'\xb5'
1950 # s = u'\xb5'
1951 # s.encode(sys.getdefaultencoding())
1951 # s.encode(sys.getdefaultencoding())
1952 #
1952 #
1953 # is not sufficient, as I've seen terminals where that fails but
1953 # is not sufficient, as I've seen terminals where that fails but
1954 # print s
1954 # print s
1955 #
1955 #
1956 # succeeds
1956 # succeeds
1957 #
1957 #
1958 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1958 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1959
1959
1960 #units = [u"s", u"ms",u'\xb5',"ns"]
1960 #units = [u"s", u"ms",u'\xb5',"ns"]
1961 units = [u"s", u"ms",u'us',"ns"]
1961 units = [u"s", u"ms",u'us',"ns"]
1962
1962
1963 scaling = [1, 1e3, 1e6, 1e9]
1963 scaling = [1, 1e3, 1e6, 1e9]
1964
1964
1965 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1965 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1966 posix=False, strict=False)
1966 posix=False, strict=False)
1967 if stmt == "":
1967 if stmt == "":
1968 return
1968 return
1969 timefunc = timeit.default_timer
1969 timefunc = timeit.default_timer
1970 number = int(getattr(opts, "n", 0))
1970 number = int(getattr(opts, "n", 0))
1971 repeat = int(getattr(opts, "r", timeit.default_repeat))
1971 repeat = int(getattr(opts, "r", timeit.default_repeat))
1972 precision = int(getattr(opts, "p", 3))
1972 precision = int(getattr(opts, "p", 3))
1973 if hasattr(opts, "t"):
1973 if hasattr(opts, "t"):
1974 timefunc = time.time
1974 timefunc = time.time
1975 if hasattr(opts, "c"):
1975 if hasattr(opts, "c"):
1976 timefunc = clock
1976 timefunc = clock
1977
1977
1978 timer = timeit.Timer(timer=timefunc)
1978 timer = timeit.Timer(timer=timefunc)
1979 # this code has tight coupling to the inner workings of timeit.Timer,
1979 # this code has tight coupling to the inner workings of timeit.Timer,
1980 # but is there a better way to achieve that the code stmt has access
1980 # but is there a better way to achieve that the code stmt has access
1981 # to the shell namespace?
1981 # to the shell namespace?
1982
1982
1983 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1983 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1984 'setup': "pass"}
1984 'setup': "pass"}
1985 # Track compilation time so it can be reported if too long
1985 # Track compilation time so it can be reported if too long
1986 # Minimum time above which compilation time will be reported
1986 # Minimum time above which compilation time will be reported
1987 tc_min = 0.1
1987 tc_min = 0.1
1988
1988
1989 t0 = clock()
1989 t0 = clock()
1990 code = compile(src, "<magic-timeit>", "exec")
1990 code = compile(src, "<magic-timeit>", "exec")
1991 tc = clock()-t0
1991 tc = clock()-t0
1992
1992
1993 ns = {}
1993 ns = {}
1994 exec code in self.shell.user_ns, ns
1994 exec code in self.shell.user_ns, ns
1995 timer.inner = ns["inner"]
1995 timer.inner = ns["inner"]
1996
1996
1997 if number == 0:
1997 if number == 0:
1998 # determine number so that 0.2 <= total time < 2.0
1998 # determine number so that 0.2 <= total time < 2.0
1999 number = 1
1999 number = 1
2000 for i in range(1, 10):
2000 for i in range(1, 10):
2001 if timer.timeit(number) >= 0.2:
2001 if timer.timeit(number) >= 0.2:
2002 break
2002 break
2003 number *= 10
2003 number *= 10
2004
2004
2005 best = min(timer.repeat(repeat, number)) / number
2005 best = min(timer.repeat(repeat, number)) / number
2006
2006
2007 if best > 0.0 and best < 1000.0:
2007 if best > 0.0 and best < 1000.0:
2008 order = min(-int(math.floor(math.log10(best)) // 3), 3)
2008 order = min(-int(math.floor(math.log10(best)) // 3), 3)
2009 elif best >= 1000.0:
2009 elif best >= 1000.0:
2010 order = 0
2010 order = 0
2011 else:
2011 else:
2012 order = 3
2012 order = 3
2013 print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
2013 print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
2014 precision,
2014 precision,
2015 best * scaling[order],
2015 best * scaling[order],
2016 units[order])
2016 units[order])
2017 if tc > tc_min:
2017 if tc > tc_min:
2018 print "Compiler time: %.2f s" % tc
2018 print "Compiler time: %.2f s" % tc
2019
2019
2020 @skip_doctest
2020 @skip_doctest
2021 @needs_local_scope
2021 @needs_local_scope
2022 def magic_time(self,parameter_s = ''):
2022 def magic_time(self,parameter_s = ''):
2023 """Time execution of a Python statement or expression.
2023 """Time execution of a Python statement or expression.
2024
2024
2025 The CPU and wall clock times are printed, and the value of the
2025 The CPU and wall clock times are printed, and the value of the
2026 expression (if any) is returned. Note that under Win32, system time
2026 expression (if any) is returned. Note that under Win32, system time
2027 is always reported as 0, since it can not be measured.
2027 is always reported as 0, since it can not be measured.
2028
2028
2029 This function provides very basic timing functionality. In Python
2029 This function provides very basic timing functionality. In Python
2030 2.3, the timeit module offers more control and sophistication, so this
2030 2.3, the timeit module offers more control and sophistication, so this
2031 could be rewritten to use it (patches welcome).
2031 could be rewritten to use it (patches welcome).
2032
2032
2033 Examples
2033 Examples
2034 --------
2034 --------
2035 ::
2035 ::
2036
2036
2037 In [1]: time 2**128
2037 In [1]: time 2**128
2038 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
2038 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
2039 Wall time: 0.00
2039 Wall time: 0.00
2040 Out[1]: 340282366920938463463374607431768211456L
2040 Out[1]: 340282366920938463463374607431768211456L
2041
2041
2042 In [2]: n = 1000000
2042 In [2]: n = 1000000
2043
2043
2044 In [3]: time sum(range(n))
2044 In [3]: time sum(range(n))
2045 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
2045 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
2046 Wall time: 1.37
2046 Wall time: 1.37
2047 Out[3]: 499999500000L
2047 Out[3]: 499999500000L
2048
2048
2049 In [4]: time print 'hello world'
2049 In [4]: time print 'hello world'
2050 hello world
2050 hello world
2051 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
2051 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
2052 Wall time: 0.00
2052 Wall time: 0.00
2053
2053
2054 Note that the time needed by Python to compile the given expression
2054 Note that the time needed by Python to compile the given expression
2055 will be reported if it is more than 0.1s. In this example, the
2055 will be reported if it is more than 0.1s. In this example, the
2056 actual exponentiation is done by Python at compilation time, so while
2056 actual exponentiation is done by Python at compilation time, so while
2057 the expression can take a noticeable amount of time to compute, that
2057 the expression can take a noticeable amount of time to compute, that
2058 time is purely due to the compilation:
2058 time is purely due to the compilation:
2059
2059
2060 In [5]: time 3**9999;
2060 In [5]: time 3**9999;
2061 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
2061 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
2062 Wall time: 0.00 s
2062 Wall time: 0.00 s
2063
2063
2064 In [6]: time 3**999999;
2064 In [6]: time 3**999999;
2065 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
2065 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
2066 Wall time: 0.00 s
2066 Wall time: 0.00 s
2067 Compiler : 0.78 s
2067 Compiler : 0.78 s
2068 """
2068 """
2069
2069
2070 # fail immediately if the given expression can't be compiled
2070 # fail immediately if the given expression can't be compiled
2071
2071
2072 expr = self.shell.prefilter(parameter_s,False)
2072 expr = self.shell.prefilter(parameter_s,False)
2073
2073
2074 # Minimum time above which compilation time will be reported
2074 # Minimum time above which compilation time will be reported
2075 tc_min = 0.1
2075 tc_min = 0.1
2076
2076
2077 try:
2077 try:
2078 mode = 'eval'
2078 mode = 'eval'
2079 t0 = clock()
2079 t0 = clock()
2080 code = compile(expr,'<timed eval>',mode)
2080 code = compile(expr,'<timed eval>',mode)
2081 tc = clock()-t0
2081 tc = clock()-t0
2082 except SyntaxError:
2082 except SyntaxError:
2083 mode = 'exec'
2083 mode = 'exec'
2084 t0 = clock()
2084 t0 = clock()
2085 code = compile(expr,'<timed exec>',mode)
2085 code = compile(expr,'<timed exec>',mode)
2086 tc = clock()-t0
2086 tc = clock()-t0
2087 # skew measurement as little as possible
2087 # skew measurement as little as possible
2088 glob = self.shell.user_ns
2088 glob = self.shell.user_ns
2089 locs = self._magic_locals
2089 locs = self._magic_locals
2090 clk = clock2
2090 clk = clock2
2091 wtime = time.time
2091 wtime = time.time
2092 # time execution
2092 # time execution
2093 wall_st = wtime()
2093 wall_st = wtime()
2094 if mode=='eval':
2094 if mode=='eval':
2095 st = clk()
2095 st = clk()
2096 out = eval(code, glob, locs)
2096 out = eval(code, glob, locs)
2097 end = clk()
2097 end = clk()
2098 else:
2098 else:
2099 st = clk()
2099 st = clk()
2100 exec code in glob, locs
2100 exec code in glob, locs
2101 end = clk()
2101 end = clk()
2102 out = None
2102 out = None
2103 wall_end = wtime()
2103 wall_end = wtime()
2104 # Compute actual times and report
2104 # Compute actual times and report
2105 wall_time = wall_end-wall_st
2105 wall_time = wall_end-wall_st
2106 cpu_user = end[0]-st[0]
2106 cpu_user = end[0]-st[0]
2107 cpu_sys = end[1]-st[1]
2107 cpu_sys = end[1]-st[1]
2108 cpu_tot = cpu_user+cpu_sys
2108 cpu_tot = cpu_user+cpu_sys
2109 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
2109 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
2110 (cpu_user,cpu_sys,cpu_tot)
2110 (cpu_user,cpu_sys,cpu_tot)
2111 print "Wall time: %.2f s" % wall_time
2111 print "Wall time: %.2f s" % wall_time
2112 if tc > tc_min:
2112 if tc > tc_min:
2113 print "Compiler : %.2f s" % tc
2113 print "Compiler : %.2f s" % tc
2114 return out
2114 return out
2115
2115
2116 @skip_doctest
2116 @skip_doctest
2117 def magic_macro(self,parameter_s = ''):
2117 def magic_macro(self,parameter_s = ''):
2118 """Define a macro for future re-execution. It accepts ranges of history,
2118 """Define a macro for future re-execution. It accepts ranges of history,
2119 filenames or string objects.
2119 filenames or string objects.
2120
2120
2121 Usage:\\
2121 Usage:\\
2122 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
2122 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
2123
2123
2124 Options:
2124 Options:
2125
2125
2126 -r: use 'raw' input. By default, the 'processed' history is used,
2126 -r: use 'raw' input. By default, the 'processed' history is used,
2127 so that magics are loaded in their transformed version to valid
2127 so that magics are loaded in their transformed version to valid
2128 Python. If this option is given, the raw input as typed as the
2128 Python. If this option is given, the raw input as typed as the
2129 command line is used instead.
2129 command line is used instead.
2130
2130
2131 This will define a global variable called `name` which is a string
2131 This will define a global variable called `name` which is a string
2132 made of joining the slices and lines you specify (n1,n2,... numbers
2132 made of joining the slices and lines you specify (n1,n2,... numbers
2133 above) from your input history into a single string. This variable
2133 above) from your input history into a single string. This variable
2134 acts like an automatic function which re-executes those lines as if
2134 acts like an automatic function which re-executes those lines as if
2135 you had typed them. You just type 'name' at the prompt and the code
2135 you had typed them. You just type 'name' at the prompt and the code
2136 executes.
2136 executes.
2137
2137
2138 The syntax for indicating input ranges is described in %history.
2138 The syntax for indicating input ranges is described in %history.
2139
2139
2140 Note: as a 'hidden' feature, you can also use traditional python slice
2140 Note: as a 'hidden' feature, you can also use traditional python slice
2141 notation, where N:M means numbers N through M-1.
2141 notation, where N:M means numbers N through M-1.
2142
2142
2143 For example, if your history contains (%hist prints it)::
2143 For example, if your history contains (%hist prints it)::
2144
2144
2145 44: x=1
2145 44: x=1
2146 45: y=3
2146 45: y=3
2147 46: z=x+y
2147 46: z=x+y
2148 47: print x
2148 47: print x
2149 48: a=5
2149 48: a=5
2150 49: print 'x',x,'y',y
2150 49: print 'x',x,'y',y
2151
2151
2152 you can create a macro with lines 44 through 47 (included) and line 49
2152 you can create a macro with lines 44 through 47 (included) and line 49
2153 called my_macro with::
2153 called my_macro with::
2154
2154
2155 In [55]: %macro my_macro 44-47 49
2155 In [55]: %macro my_macro 44-47 49
2156
2156
2157 Now, typing `my_macro` (without quotes) will re-execute all this code
2157 Now, typing `my_macro` (without quotes) will re-execute all this code
2158 in one pass.
2158 in one pass.
2159
2159
2160 You don't need to give the line-numbers in order, and any given line
2160 You don't need to give the line-numbers in order, and any given line
2161 number can appear multiple times. You can assemble macros with any
2161 number can appear multiple times. You can assemble macros with any
2162 lines from your input history in any order.
2162 lines from your input history in any order.
2163
2163
2164 The macro is a simple object which holds its value in an attribute,
2164 The macro is a simple object which holds its value in an attribute,
2165 but IPython's display system checks for macros and executes them as
2165 but IPython's display system checks for macros and executes them as
2166 code instead of printing them when you type their name.
2166 code instead of printing them when you type their name.
2167
2167
2168 You can view a macro's contents by explicitly printing it with::
2168 You can view a macro's contents by explicitly printing it with::
2169
2169
2170 print macro_name
2170 print macro_name
2171
2171
2172 """
2172 """
2173 opts,args = self.parse_options(parameter_s,'r',mode='list')
2173 opts,args = self.parse_options(parameter_s,'r',mode='list')
2174 if not args: # List existing macros
2174 if not args: # List existing macros
2175 return sorted(k for k,v in self.shell.user_ns.iteritems() if\
2175 return sorted(k for k,v in self.shell.user_ns.iteritems() if\
2176 isinstance(v, Macro))
2176 isinstance(v, Macro))
2177 if len(args) == 1:
2177 if len(args) == 1:
2178 raise UsageError(
2178 raise UsageError(
2179 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
2179 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
2180 name, codefrom = args[0], " ".join(args[1:])
2180 name, codefrom = args[0], " ".join(args[1:])
2181
2181
2182 #print 'rng',ranges # dbg
2182 #print 'rng',ranges # dbg
2183 try:
2183 try:
2184 lines = self.shell.find_user_code(codefrom, 'r' in opts)
2184 lines = self.shell.find_user_code(codefrom, 'r' in opts)
2185 except (ValueError, TypeError) as e:
2185 except (ValueError, TypeError) as e:
2186 print e.args[0]
2186 print e.args[0]
2187 return
2187 return
2188 macro = Macro(lines)
2188 macro = Macro(lines)
2189 self.shell.define_macro(name, macro)
2189 self.shell.define_macro(name, macro)
2190 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
2190 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
2191 print '=== Macro contents: ==='
2191 print '=== Macro contents: ==='
2192 print macro,
2192 print macro,
2193
2193
2194 def magic_save(self,parameter_s = ''):
2194 def magic_save(self,parameter_s = ''):
2195 """Save a set of lines or a macro to a given filename.
2195 """Save a set of lines or a macro to a given filename.
2196
2196
2197 Usage:\\
2197 Usage:\\
2198 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
2198 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
2199
2199
2200 Options:
2200 Options:
2201
2201
2202 -r: use 'raw' input. By default, the 'processed' history is used,
2202 -r: use 'raw' input. By default, the 'processed' history is used,
2203 so that magics are loaded in their transformed version to valid
2203 so that magics are loaded in their transformed version to valid
2204 Python. If this option is given, the raw input as typed as the
2204 Python. If this option is given, the raw input as typed as the
2205 command line is used instead.
2205 command line is used instead.
2206
2206
2207 This function uses the same syntax as %history for input ranges,
2207 This function uses the same syntax as %history for input ranges,
2208 then saves the lines to the filename you specify.
2208 then saves the lines to the filename you specify.
2209
2209
2210 It adds a '.py' extension to the file if you don't do so yourself, and
2210 It adds a '.py' extension to the file if you don't do so yourself, and
2211 it asks for confirmation before overwriting existing files."""
2211 it asks for confirmation before overwriting existing files."""
2212
2212
2213 opts,args = self.parse_options(parameter_s,'r',mode='list')
2213 opts,args = self.parse_options(parameter_s,'r',mode='list')
2214 fname, codefrom = unquote_filename(args[0]), " ".join(args[1:])
2214 fname, codefrom = unquote_filename(args[0]), " ".join(args[1:])
2215 if not fname.endswith('.py'):
2215 if not fname.endswith('.py'):
2216 fname += '.py'
2216 fname += '.py'
2217 if os.path.isfile(fname):
2217 if os.path.isfile(fname):
2218 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
2218 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
2219 if ans.lower() not in ['y','yes']:
2219 if ans.lower() not in ['y','yes']:
2220 print 'Operation cancelled.'
2220 print 'Operation cancelled.'
2221 return
2221 return
2222 try:
2222 try:
2223 cmds = self.shell.find_user_code(codefrom, 'r' in opts)
2223 cmds = self.shell.find_user_code(codefrom, 'r' in opts)
2224 except (TypeError, ValueError) as e:
2224 except (TypeError, ValueError) as e:
2225 print e.args[0]
2225 print e.args[0]
2226 return
2226 return
2227 with io.open(fname,'w', encoding="utf-8") as f:
2227 with io.open(fname,'w', encoding="utf-8") as f:
2228 f.write(u"# coding: utf-8\n")
2228 f.write(u"# coding: utf-8\n")
2229 f.write(py3compat.cast_unicode(cmds))
2229 f.write(py3compat.cast_unicode(cmds))
2230 print 'The following commands were written to file `%s`:' % fname
2230 print 'The following commands were written to file `%s`:' % fname
2231 print cmds
2231 print cmds
2232
2232
2233 def magic_pastebin(self, parameter_s = ''):
2233 def magic_pastebin(self, parameter_s = ''):
2234 """Upload code to the 'Lodge it' paste bin, returning the URL."""
2234 """Upload code to the 'Lodge it' paste bin, returning the URL."""
2235 try:
2235 try:
2236 code = self.shell.find_user_code(parameter_s)
2236 code = self.shell.find_user_code(parameter_s)
2237 except (ValueError, TypeError) as e:
2237 except (ValueError, TypeError) as e:
2238 print e.args[0]
2238 print e.args[0]
2239 return
2239 return
2240 pbserver = ServerProxy('http://paste.pocoo.org/xmlrpc/')
2240 pbserver = ServerProxy('http://paste.pocoo.org/xmlrpc/')
2241 id = pbserver.pastes.newPaste("python", code)
2241 id = pbserver.pastes.newPaste("python", code)
2242 return "http://paste.pocoo.org/show/" + id
2242 return "http://paste.pocoo.org/show/" + id
2243
2243
2244 def magic_loadpy(self, arg_s):
2244 def magic_loadpy(self, arg_s):
2245 """Load a .py python script into the GUI console.
2245 """Load a .py python script into the GUI console.
2246
2246
2247 This magic command can either take a local filename or a url::
2247 This magic command can either take a local filename or a url::
2248
2248
2249 %loadpy myscript.py
2249 %loadpy myscript.py
2250 %loadpy http://www.example.com/myscript.py
2250 %loadpy http://www.example.com/myscript.py
2251 """
2251 """
2252 arg_s = unquote_filename(arg_s)
2252 arg_s = unquote_filename(arg_s)
2253 remote_url = arg_s.startswith(('http://', 'https://'))
2253 remote_url = arg_s.startswith(('http://', 'https://'))
2254 local_url = not remote_url
2254 local_url = not remote_url
2255 if local_url and not arg_s.endswith('.py'):
2255 if local_url and not arg_s.endswith('.py'):
2256 # Local files must be .py; for remote URLs it's possible that the
2256 # Local files must be .py; for remote URLs it's possible that the
2257 # fetch URL doesn't have a .py in it (many servers have an opaque
2257 # fetch URL doesn't have a .py in it (many servers have an opaque
2258 # URL, such as scipy-central.org).
2258 # URL, such as scipy-central.org).
2259 raise ValueError('%%loadpy only works with .py files: %s' % arg_s)
2259 raise ValueError('%%loadpy only works with .py files: %s' % arg_s)
2260
2260
2261 # openpy takes care of finding the source encoding (per PEP 263)
2261 # openpy takes care of finding the source encoding (per PEP 263)
2262 if remote_url:
2262 if remote_url:
2263 contents = openpy.read_py_url(arg_s, skip_encoding_cookie=True)
2263 contents = openpy.read_py_url(arg_s, skip_encoding_cookie=True)
2264 else:
2264 else:
2265 contents = openpy.read_py_file(arg_s, skip_encoding_cookie=True)
2265 contents = openpy.read_py_file(arg_s, skip_encoding_cookie=True)
2266
2266
2267 self.set_next_input(contents)
2267 self.set_next_input(contents)
2268
2268
2269 def _find_edit_target(self, args, opts, last_call):
2269 def _find_edit_target(self, args, opts, last_call):
2270 """Utility method used by magic_edit to find what to edit."""
2270 """Utility method used by magic_edit to find what to edit."""
2271
2271
2272 def make_filename(arg):
2272 def make_filename(arg):
2273 "Make a filename from the given args"
2273 "Make a filename from the given args"
2274 arg = unquote_filename(arg)
2274 arg = unquote_filename(arg)
2275 try:
2275 try:
2276 filename = get_py_filename(arg)
2276 filename = get_py_filename(arg)
2277 except IOError:
2277 except IOError:
2278 # If it ends with .py but doesn't already exist, assume we want
2278 # If it ends with .py but doesn't already exist, assume we want
2279 # a new file.
2279 # a new file.
2280 if arg.endswith('.py'):
2280 if arg.endswith('.py'):
2281 filename = arg
2281 filename = arg
2282 else:
2282 else:
2283 filename = None
2283 filename = None
2284 return filename
2284 return filename
2285
2285
2286 # Set a few locals from the options for convenience:
2286 # Set a few locals from the options for convenience:
2287 opts_prev = 'p' in opts
2287 opts_prev = 'p' in opts
2288 opts_raw = 'r' in opts
2288 opts_raw = 'r' in opts
2289
2289
2290 # custom exceptions
2290 # custom exceptions
2291 class DataIsObject(Exception): pass
2291 class DataIsObject(Exception): pass
2292
2292
2293 # Default line number value
2293 # Default line number value
2294 lineno = opts.get('n',None)
2294 lineno = opts.get('n',None)
2295
2295
2296 if opts_prev:
2296 if opts_prev:
2297 args = '_%s' % last_call[0]
2297 args = '_%s' % last_call[0]
2298 if not self.shell.user_ns.has_key(args):
2298 if not self.shell.user_ns.has_key(args):
2299 args = last_call[1]
2299 args = last_call[1]
2300
2300
2301 # use last_call to remember the state of the previous call, but don't
2301 # use last_call to remember the state of the previous call, but don't
2302 # let it be clobbered by successive '-p' calls.
2302 # let it be clobbered by successive '-p' calls.
2303 try:
2303 try:
2304 last_call[0] = self.shell.displayhook.prompt_count
2304 last_call[0] = self.shell.displayhook.prompt_count
2305 if not opts_prev:
2305 if not opts_prev:
2306 last_call[1] = args
2306 last_call[1] = args
2307 except:
2307 except:
2308 pass
2308 pass
2309
2309
2310 # by default this is done with temp files, except when the given
2310 # by default this is done with temp files, except when the given
2311 # arg is a filename
2311 # arg is a filename
2312 use_temp = True
2312 use_temp = True
2313
2313
2314 data = ''
2314 data = ''
2315
2315
2316 # First, see if the arguments should be a filename.
2316 # First, see if the arguments should be a filename.
2317 filename = make_filename(args)
2317 filename = make_filename(args)
2318 if filename:
2318 if filename:
2319 use_temp = False
2319 use_temp = False
2320 elif args:
2320 elif args:
2321 # Mode where user specifies ranges of lines, like in %macro.
2321 # Mode where user specifies ranges of lines, like in %macro.
2322 data = self.extract_input_lines(args, opts_raw)
2322 data = self.extract_input_lines(args, opts_raw)
2323 if not data:
2323 if not data:
2324 try:
2324 try:
2325 # Load the parameter given as a variable. If not a string,
2325 # Load the parameter given as a variable. If not a string,
2326 # process it as an object instead (below)
2326 # process it as an object instead (below)
2327
2327
2328 #print '*** args',args,'type',type(args) # dbg
2328 #print '*** args',args,'type',type(args) # dbg
2329 data = eval(args, self.shell.user_ns)
2329 data = eval(args, self.shell.user_ns)
2330 if not isinstance(data, basestring):
2330 if not isinstance(data, basestring):
2331 raise DataIsObject
2331 raise DataIsObject
2332
2332
2333 except (NameError,SyntaxError):
2333 except (NameError,SyntaxError):
2334 # given argument is not a variable, try as a filename
2334 # given argument is not a variable, try as a filename
2335 filename = make_filename(args)
2335 filename = make_filename(args)
2336 if filename is None:
2336 if filename is None:
2337 warn("Argument given (%s) can't be found as a variable "
2337 warn("Argument given (%s) can't be found as a variable "
2338 "or as a filename." % args)
2338 "or as a filename." % args)
2339 return
2339 return
2340 use_temp = False
2340 use_temp = False
2341
2341
2342 except DataIsObject:
2342 except DataIsObject:
2343 # macros have a special edit function
2343 # macros have a special edit function
2344 if isinstance(data, Macro):
2344 if isinstance(data, Macro):
2345 raise MacroToEdit(data)
2345 raise MacroToEdit(data)
2346
2346
2347 # For objects, try to edit the file where they are defined
2347 # For objects, try to edit the file where they are defined
2348 try:
2348 try:
2349 filename = inspect.getabsfile(data)
2349 filename = inspect.getabsfile(data)
2350 if 'fakemodule' in filename.lower() and inspect.isclass(data):
2350 if 'fakemodule' in filename.lower() and inspect.isclass(data):
2351 # class created by %edit? Try to find source
2351 # class created by %edit? Try to find source
2352 # by looking for method definitions instead, the
2352 # by looking for method definitions instead, the
2353 # __module__ in those classes is FakeModule.
2353 # __module__ in those classes is FakeModule.
2354 attrs = [getattr(data, aname) for aname in dir(data)]
2354 attrs = [getattr(data, aname) for aname in dir(data)]
2355 for attr in attrs:
2355 for attr in attrs:
2356 if not inspect.ismethod(attr):
2356 if not inspect.ismethod(attr):
2357 continue
2357 continue
2358 filename = inspect.getabsfile(attr)
2358 filename = inspect.getabsfile(attr)
2359 if filename and 'fakemodule' not in filename.lower():
2359 if filename and 'fakemodule' not in filename.lower():
2360 # change the attribute to be the edit target instead
2360 # change the attribute to be the edit target instead
2361 data = attr
2361 data = attr
2362 break
2362 break
2363
2363
2364 datafile = 1
2364 datafile = 1
2365 except TypeError:
2365 except TypeError:
2366 filename = make_filename(args)
2366 filename = make_filename(args)
2367 datafile = 1
2367 datafile = 1
2368 warn('Could not find file where `%s` is defined.\n'
2368 warn('Could not find file where `%s` is defined.\n'
2369 'Opening a file named `%s`' % (args,filename))
2369 'Opening a file named `%s`' % (args,filename))
2370 # Now, make sure we can actually read the source (if it was in
2370 # Now, make sure we can actually read the source (if it was in
2371 # a temp file it's gone by now).
2371 # a temp file it's gone by now).
2372 if datafile:
2372 if datafile:
2373 try:
2373 try:
2374 if lineno is None:
2374 if lineno is None:
2375 lineno = inspect.getsourcelines(data)[1]
2375 lineno = inspect.getsourcelines(data)[1]
2376 except IOError:
2376 except IOError:
2377 filename = make_filename(args)
2377 filename = make_filename(args)
2378 if filename is None:
2378 if filename is None:
2379 warn('The file `%s` where `%s` was defined cannot '
2379 warn('The file `%s` where `%s` was defined cannot '
2380 'be read.' % (filename,data))
2380 'be read.' % (filename,data))
2381 return
2381 return
2382 use_temp = False
2382 use_temp = False
2383
2383
2384 if use_temp:
2384 if use_temp:
2385 filename = self.shell.mktempfile(data)
2385 filename = self.shell.mktempfile(data)
2386 print 'IPython will make a temporary file named:',filename
2386 print 'IPython will make a temporary file named:',filename
2387
2387
2388 return filename, lineno, use_temp
2388 return filename, lineno, use_temp
2389
2389
2390 def _edit_macro(self,mname,macro):
2390 def _edit_macro(self,mname,macro):
2391 """open an editor with the macro data in a file"""
2391 """open an editor with the macro data in a file"""
2392 filename = self.shell.mktempfile(macro.value)
2392 filename = self.shell.mktempfile(macro.value)
2393 self.shell.hooks.editor(filename)
2393 self.shell.hooks.editor(filename)
2394
2394
2395 # and make a new macro object, to replace the old one
2395 # and make a new macro object, to replace the old one
2396 mfile = open(filename)
2396 mfile = open(filename)
2397 mvalue = mfile.read()
2397 mvalue = mfile.read()
2398 mfile.close()
2398 mfile.close()
2399 self.shell.user_ns[mname] = Macro(mvalue)
2399 self.shell.user_ns[mname] = Macro(mvalue)
2400
2400
2401 def magic_ed(self,parameter_s=''):
2401 def magic_ed(self,parameter_s=''):
2402 """Alias to %edit."""
2402 """Alias to %edit."""
2403 return self.magic_edit(parameter_s)
2403 return self.magic_edit(parameter_s)
2404
2404
2405 @skip_doctest
2405 @skip_doctest
2406 def magic_edit(self,parameter_s='',last_call=['','']):
2406 def magic_edit(self,parameter_s='',last_call=['','']):
2407 """Bring up an editor and execute the resulting code.
2407 """Bring up an editor and execute the resulting code.
2408
2408
2409 Usage:
2409 Usage:
2410 %edit [options] [args]
2410 %edit [options] [args]
2411
2411
2412 %edit runs IPython's editor hook. The default version of this hook is
2412 %edit runs IPython's editor hook. The default version of this hook is
2413 set to call the editor specified by your $EDITOR environment variable.
2413 set to call the editor specified by your $EDITOR environment variable.
2414 If this isn't found, it will default to vi under Linux/Unix and to
2414 If this isn't found, it will default to vi under Linux/Unix and to
2415 notepad under Windows. See the end of this docstring for how to change
2415 notepad under Windows. See the end of this docstring for how to change
2416 the editor hook.
2416 the editor hook.
2417
2417
2418 You can also set the value of this editor via the
2418 You can also set the value of this editor via the
2419 ``TerminalInteractiveShell.editor`` option in your configuration file.
2419 ``TerminalInteractiveShell.editor`` option in your configuration file.
2420 This is useful if you wish to use a different editor from your typical
2420 This is useful if you wish to use a different editor from your typical
2421 default with IPython (and for Windows users who typically don't set
2421 default with IPython (and for Windows users who typically don't set
2422 environment variables).
2422 environment variables).
2423
2423
2424 This command allows you to conveniently edit multi-line code right in
2424 This command allows you to conveniently edit multi-line code right in
2425 your IPython session.
2425 your IPython session.
2426
2426
2427 If called without arguments, %edit opens up an empty editor with a
2427 If called without arguments, %edit opens up an empty editor with a
2428 temporary file and will execute the contents of this file when you
2428 temporary file and will execute the contents of this file when you
2429 close it (don't forget to save it!).
2429 close it (don't forget to save it!).
2430
2430
2431
2431
2432 Options:
2432 Options:
2433
2433
2434 -n <number>: open the editor at a specified line number. By default,
2434 -n <number>: open the editor at a specified line number. By default,
2435 the IPython editor hook uses the unix syntax 'editor +N filename', but
2435 the IPython editor hook uses the unix syntax 'editor +N filename', but
2436 you can configure this by providing your own modified hook if your
2436 you can configure this by providing your own modified hook if your
2437 favorite editor supports line-number specifications with a different
2437 favorite editor supports line-number specifications with a different
2438 syntax.
2438 syntax.
2439
2439
2440 -p: this will call the editor with the same data as the previous time
2440 -p: this will call the editor with the same data as the previous time
2441 it was used, regardless of how long ago (in your current session) it
2441 it was used, regardless of how long ago (in your current session) it
2442 was.
2442 was.
2443
2443
2444 -r: use 'raw' input. This option only applies to input taken from the
2444 -r: use 'raw' input. This option only applies to input taken from the
2445 user's history. By default, the 'processed' history is used, so that
2445 user's history. By default, the 'processed' history is used, so that
2446 magics are loaded in their transformed version to valid Python. If
2446 magics are loaded in their transformed version to valid Python. If
2447 this option is given, the raw input as typed as the command line is
2447 this option is given, the raw input as typed as the command line is
2448 used instead. When you exit the editor, it will be executed by
2448 used instead. When you exit the editor, it will be executed by
2449 IPython's own processor.
2449 IPython's own processor.
2450
2450
2451 -x: do not execute the edited code immediately upon exit. This is
2451 -x: do not execute the edited code immediately upon exit. This is
2452 mainly useful if you are editing programs which need to be called with
2452 mainly useful if you are editing programs which need to be called with
2453 command line arguments, which you can then do using %run.
2453 command line arguments, which you can then do using %run.
2454
2454
2455
2455
2456 Arguments:
2456 Arguments:
2457
2457
2458 If arguments are given, the following possibilities exist:
2458 If arguments are given, the following possibilities exist:
2459
2459
2460 - If the argument is a filename, IPython will load that into the
2460 - If the argument is a filename, IPython will load that into the
2461 editor. It will execute its contents with execfile() when you exit,
2461 editor. It will execute its contents with execfile() when you exit,
2462 loading any code in the file into your interactive namespace.
2462 loading any code in the file into your interactive namespace.
2463
2463
2464 - The arguments are ranges of input history, e.g. "7 ~1/4-6".
2464 - The arguments are ranges of input history, e.g. "7 ~1/4-6".
2465 The syntax is the same as in the %history magic.
2465 The syntax is the same as in the %history magic.
2466
2466
2467 - If the argument is a string variable, its contents are loaded
2467 - If the argument is a string variable, its contents are loaded
2468 into the editor. You can thus edit any string which contains
2468 into the editor. You can thus edit any string which contains
2469 python code (including the result of previous edits).
2469 python code (including the result of previous edits).
2470
2470
2471 - If the argument is the name of an object (other than a string),
2471 - If the argument is the name of an object (other than a string),
2472 IPython will try to locate the file where it was defined and open the
2472 IPython will try to locate the file where it was defined and open the
2473 editor at the point where it is defined. You can use `%edit function`
2473 editor at the point where it is defined. You can use `%edit function`
2474 to load an editor exactly at the point where 'function' is defined,
2474 to load an editor exactly at the point where 'function' is defined,
2475 edit it and have the file be executed automatically.
2475 edit it and have the file be executed automatically.
2476
2476
2477 - If the object is a macro (see %macro for details), this opens up your
2477 - If the object is a macro (see %macro for details), this opens up your
2478 specified editor with a temporary file containing the macro's data.
2478 specified editor with a temporary file containing the macro's data.
2479 Upon exit, the macro is reloaded with the contents of the file.
2479 Upon exit, the macro is reloaded with the contents of the file.
2480
2480
2481 Note: opening at an exact line is only supported under Unix, and some
2481 Note: opening at an exact line is only supported under Unix, and some
2482 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2482 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2483 '+NUMBER' parameter necessary for this feature. Good editors like
2483 '+NUMBER' parameter necessary for this feature. Good editors like
2484 (X)Emacs, vi, jed, pico and joe all do.
2484 (X)Emacs, vi, jed, pico and joe all do.
2485
2485
2486 After executing your code, %edit will return as output the code you
2486 After executing your code, %edit will return as output the code you
2487 typed in the editor (except when it was an existing file). This way
2487 typed in the editor (except when it was an existing file). This way
2488 you can reload the code in further invocations of %edit as a variable,
2488 you can reload the code in further invocations of %edit as a variable,
2489 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2489 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2490 the output.
2490 the output.
2491
2491
2492 Note that %edit is also available through the alias %ed.
2492 Note that %edit is also available through the alias %ed.
2493
2493
2494 This is an example of creating a simple function inside the editor and
2494 This is an example of creating a simple function inside the editor and
2495 then modifying it. First, start up the editor::
2495 then modifying it. First, start up the editor::
2496
2496
2497 In [1]: ed
2497 In [1]: ed
2498 Editing... done. Executing edited code...
2498 Editing... done. Executing edited code...
2499 Out[1]: 'def foo():\\n print "foo() was defined in an editing
2499 Out[1]: 'def foo():\\n print "foo() was defined in an editing
2500 session"\\n'
2500 session"\\n'
2501
2501
2502 We can then call the function foo()::
2502 We can then call the function foo()::
2503
2503
2504 In [2]: foo()
2504 In [2]: foo()
2505 foo() was defined in an editing session
2505 foo() was defined in an editing session
2506
2506
2507 Now we edit foo. IPython automatically loads the editor with the
2507 Now we edit foo. IPython automatically loads the editor with the
2508 (temporary) file where foo() was previously defined::
2508 (temporary) file where foo() was previously defined::
2509
2509
2510 In [3]: ed foo
2510 In [3]: ed foo
2511 Editing... done. Executing edited code...
2511 Editing... done. Executing edited code...
2512
2512
2513 And if we call foo() again we get the modified version::
2513 And if we call foo() again we get the modified version::
2514
2514
2515 In [4]: foo()
2515 In [4]: foo()
2516 foo() has now been changed!
2516 foo() has now been changed!
2517
2517
2518 Here is an example of how to edit a code snippet successive
2518 Here is an example of how to edit a code snippet successive
2519 times. First we call the editor::
2519 times. First we call the editor::
2520
2520
2521 In [5]: ed
2521 In [5]: ed
2522 Editing... done. Executing edited code...
2522 Editing... done. Executing edited code...
2523 hello
2523 hello
2524 Out[5]: "print 'hello'\\n"
2524 Out[5]: "print 'hello'\\n"
2525
2525
2526 Now we call it again with the previous output (stored in _)::
2526 Now we call it again with the previous output (stored in _)::
2527
2527
2528 In [6]: ed _
2528 In [6]: ed _
2529 Editing... done. Executing edited code...
2529 Editing... done. Executing edited code...
2530 hello world
2530 hello world
2531 Out[6]: "print 'hello world'\\n"
2531 Out[6]: "print 'hello world'\\n"
2532
2532
2533 Now we call it with the output #8 (stored in _8, also as Out[8])::
2533 Now we call it with the output #8 (stored in _8, also as Out[8])::
2534
2534
2535 In [7]: ed _8
2535 In [7]: ed _8
2536 Editing... done. Executing edited code...
2536 Editing... done. Executing edited code...
2537 hello again
2537 hello again
2538 Out[7]: "print 'hello again'\\n"
2538 Out[7]: "print 'hello again'\\n"
2539
2539
2540
2540
2541 Changing the default editor hook:
2541 Changing the default editor hook:
2542
2542
2543 If you wish to write your own editor hook, you can put it in a
2543 If you wish to write your own editor hook, you can put it in a
2544 configuration file which you load at startup time. The default hook
2544 configuration file which you load at startup time. The default hook
2545 is defined in the IPython.core.hooks module, and you can use that as a
2545 is defined in the IPython.core.hooks module, and you can use that as a
2546 starting example for further modifications. That file also has
2546 starting example for further modifications. That file also has
2547 general instructions on how to set a new hook for use once you've
2547 general instructions on how to set a new hook for use once you've
2548 defined it."""
2548 defined it."""
2549 opts,args = self.parse_options(parameter_s,'prxn:')
2549 opts,args = self.parse_options(parameter_s,'prxn:')
2550
2550
2551 try:
2551 try:
2552 filename, lineno, is_temp = self._find_edit_target(args, opts, last_call)
2552 filename, lineno, is_temp = self._find_edit_target(args, opts, last_call)
2553 except MacroToEdit as e:
2553 except MacroToEdit as e:
2554 self._edit_macro(args, e.args[0])
2554 self._edit_macro(args, e.args[0])
2555 return
2555 return
2556
2556
2557 # do actual editing here
2557 # do actual editing here
2558 print 'Editing...',
2558 print 'Editing...',
2559 sys.stdout.flush()
2559 sys.stdout.flush()
2560 try:
2560 try:
2561 # Quote filenames that may have spaces in them
2561 # Quote filenames that may have spaces in them
2562 if ' ' in filename:
2562 if ' ' in filename:
2563 filename = "'%s'" % filename
2563 filename = "'%s'" % filename
2564 self.shell.hooks.editor(filename,lineno)
2564 self.shell.hooks.editor(filename,lineno)
2565 except TryNext:
2565 except TryNext:
2566 warn('Could not open editor')
2566 warn('Could not open editor')
2567 return
2567 return
2568
2568
2569 # XXX TODO: should this be generalized for all string vars?
2569 # XXX TODO: should this be generalized for all string vars?
2570 # For now, this is special-cased to blocks created by cpaste
2570 # For now, this is special-cased to blocks created by cpaste
2571 if args.strip() == 'pasted_block':
2571 if args.strip() == 'pasted_block':
2572 self.shell.user_ns['pasted_block'] = file_read(filename)
2572 self.shell.user_ns['pasted_block'] = file_read(filename)
2573
2573
2574 if 'x' in opts: # -x prevents actual execution
2574 if 'x' in opts: # -x prevents actual execution
2575 print
2575 print
2576 else:
2576 else:
2577 print 'done. Executing edited code...'
2577 print 'done. Executing edited code...'
2578 if 'r' in opts: # Untranslated IPython code
2578 if 'r' in opts: # Untranslated IPython code
2579 self.shell.run_cell(file_read(filename),
2579 self.shell.run_cell(file_read(filename),
2580 store_history=False)
2580 store_history=False)
2581 else:
2581 else:
2582 self.shell.safe_execfile(filename,self.shell.user_ns,
2582 self.shell.safe_execfile(filename,self.shell.user_ns,
2583 self.shell.user_ns)
2583 self.shell.user_ns)
2584
2584
2585 if is_temp:
2585 if is_temp:
2586 try:
2586 try:
2587 return open(filename).read()
2587 return open(filename).read()
2588 except IOError,msg:
2588 except IOError,msg:
2589 if msg.filename == filename:
2589 if msg.filename == filename:
2590 warn('File not found. Did you forget to save?')
2590 warn('File not found. Did you forget to save?')
2591 return
2591 return
2592 else:
2592 else:
2593 self.shell.showtraceback()
2593 self.shell.showtraceback()
2594
2594
2595 def magic_xmode(self,parameter_s = ''):
2595 def magic_xmode(self,parameter_s = ''):
2596 """Switch modes for the exception handlers.
2596 """Switch modes for the exception handlers.
2597
2597
2598 Valid modes: Plain, Context and Verbose.
2598 Valid modes: Plain, Context and Verbose.
2599
2599
2600 If called without arguments, acts as a toggle."""
2600 If called without arguments, acts as a toggle."""
2601
2601
2602 def xmode_switch_err(name):
2602 def xmode_switch_err(name):
2603 warn('Error changing %s exception modes.\n%s' %
2603 warn('Error changing %s exception modes.\n%s' %
2604 (name,sys.exc_info()[1]))
2604 (name,sys.exc_info()[1]))
2605
2605
2606 shell = self.shell
2606 shell = self.shell
2607 new_mode = parameter_s.strip().capitalize()
2607 new_mode = parameter_s.strip().capitalize()
2608 try:
2608 try:
2609 shell.InteractiveTB.set_mode(mode=new_mode)
2609 shell.InteractiveTB.set_mode(mode=new_mode)
2610 print 'Exception reporting mode:',shell.InteractiveTB.mode
2610 print 'Exception reporting mode:',shell.InteractiveTB.mode
2611 except:
2611 except:
2612 xmode_switch_err('user')
2612 xmode_switch_err('user')
2613
2613
2614 def magic_colors(self,parameter_s = ''):
2614 def magic_colors(self,parameter_s = ''):
2615 """Switch color scheme for prompts, info system and exception handlers.
2615 """Switch color scheme for prompts, info system and exception handlers.
2616
2616
2617 Currently implemented schemes: NoColor, Linux, LightBG.
2617 Currently implemented schemes: NoColor, Linux, LightBG.
2618
2618
2619 Color scheme names are not case-sensitive.
2619 Color scheme names are not case-sensitive.
2620
2620
2621 Examples
2621 Examples
2622 --------
2622 --------
2623 To get a plain black and white terminal::
2623 To get a plain black and white terminal::
2624
2624
2625 %colors nocolor
2625 %colors nocolor
2626 """
2626 """
2627
2627
2628 def color_switch_err(name):
2628 def color_switch_err(name):
2629 warn('Error changing %s color schemes.\n%s' %
2629 warn('Error changing %s color schemes.\n%s' %
2630 (name,sys.exc_info()[1]))
2630 (name,sys.exc_info()[1]))
2631
2631
2632
2632
2633 new_scheme = parameter_s.strip()
2633 new_scheme = parameter_s.strip()
2634 if not new_scheme:
2634 if not new_scheme:
2635 raise UsageError(
2635 raise UsageError(
2636 "%colors: you must specify a color scheme. See '%colors?'")
2636 "%colors: you must specify a color scheme. See '%colors?'")
2637 return
2637 return
2638 # local shortcut
2638 # local shortcut
2639 shell = self.shell
2639 shell = self.shell
2640
2640
2641 import IPython.utils.rlineimpl as readline
2641 import IPython.utils.rlineimpl as readline
2642
2642
2643 if not shell.colors_force and \
2643 if not shell.colors_force and \
2644 not readline.have_readline and sys.platform == "win32":
2644 not readline.have_readline and sys.platform == "win32":
2645 msg = """\
2645 msg = """\
2646 Proper color support under MS Windows requires the pyreadline library.
2646 Proper color support under MS Windows requires the pyreadline library.
2647 You can find it at:
2647 You can find it at:
2648 http://ipython.org/pyreadline.html
2648 http://ipython.org/pyreadline.html
2649 Gary's readline needs the ctypes module, from:
2649 Gary's readline needs the ctypes module, from:
2650 http://starship.python.net/crew/theller/ctypes
2650 http://starship.python.net/crew/theller/ctypes
2651 (Note that ctypes is already part of Python versions 2.5 and newer).
2651 (Note that ctypes is already part of Python versions 2.5 and newer).
2652
2652
2653 Defaulting color scheme to 'NoColor'"""
2653 Defaulting color scheme to 'NoColor'"""
2654 new_scheme = 'NoColor'
2654 new_scheme = 'NoColor'
2655 warn(msg)
2655 warn(msg)
2656
2656
2657 # readline option is 0
2657 # readline option is 0
2658 if not shell.colors_force and not shell.has_readline:
2658 if not shell.colors_force and not shell.has_readline:
2659 new_scheme = 'NoColor'
2659 new_scheme = 'NoColor'
2660
2660
2661 # Set prompt colors
2661 # Set prompt colors
2662 try:
2662 try:
2663 shell.prompt_manager.color_scheme = new_scheme
2663 shell.prompt_manager.color_scheme = new_scheme
2664 except:
2664 except:
2665 color_switch_err('prompt')
2665 color_switch_err('prompt')
2666 else:
2666 else:
2667 shell.colors = \
2667 shell.colors = \
2668 shell.prompt_manager.color_scheme_table.active_scheme_name
2668 shell.prompt_manager.color_scheme_table.active_scheme_name
2669 # Set exception colors
2669 # Set exception colors
2670 try:
2670 try:
2671 shell.InteractiveTB.set_colors(scheme = new_scheme)
2671 shell.InteractiveTB.set_colors(scheme = new_scheme)
2672 shell.SyntaxTB.set_colors(scheme = new_scheme)
2672 shell.SyntaxTB.set_colors(scheme = new_scheme)
2673 except:
2673 except:
2674 color_switch_err('exception')
2674 color_switch_err('exception')
2675
2675
2676 # Set info (for 'object?') colors
2676 # Set info (for 'object?') colors
2677 if shell.color_info:
2677 if shell.color_info:
2678 try:
2678 try:
2679 shell.inspector.set_active_scheme(new_scheme)
2679 shell.inspector.set_active_scheme(new_scheme)
2680 except:
2680 except:
2681 color_switch_err('object inspector')
2681 color_switch_err('object inspector')
2682 else:
2682 else:
2683 shell.inspector.set_active_scheme('NoColor')
2683 shell.inspector.set_active_scheme('NoColor')
2684
2684
2685 def magic_pprint(self, parameter_s=''):
2685 def magic_pprint(self, parameter_s=''):
2686 """Toggle pretty printing on/off."""
2686 """Toggle pretty printing on/off."""
2687 ptformatter = self.shell.display_formatter.formatters['text/plain']
2687 ptformatter = self.shell.display_formatter.formatters['text/plain']
2688 ptformatter.pprint = bool(1 - ptformatter.pprint)
2688 ptformatter.pprint = bool(1 - ptformatter.pprint)
2689 print 'Pretty printing has been turned', \
2689 print 'Pretty printing has been turned', \
2690 ['OFF','ON'][ptformatter.pprint]
2690 ['OFF','ON'][ptformatter.pprint]
2691
2691
2692 #......................................................................
2692 #......................................................................
2693 # Functions to implement unix shell-type things
2693 # Functions to implement unix shell-type things
2694
2694
2695 @skip_doctest
2695 @skip_doctest
2696 def magic_alias(self, parameter_s = ''):
2696 def magic_alias(self, parameter_s = ''):
2697 """Define an alias for a system command.
2697 """Define an alias for a system command.
2698
2698
2699 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2699 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2700
2700
2701 Then, typing 'alias_name params' will execute the system command 'cmd
2701 Then, typing 'alias_name params' will execute the system command 'cmd
2702 params' (from your underlying operating system).
2702 params' (from your underlying operating system).
2703
2703
2704 Aliases have lower precedence than magic functions and Python normal
2704 Aliases have lower precedence than magic functions and Python normal
2705 variables, so if 'foo' is both a Python variable and an alias, the
2705 variables, so if 'foo' is both a Python variable and an alias, the
2706 alias can not be executed until 'del foo' removes the Python variable.
2706 alias can not be executed until 'del foo' removes the Python variable.
2707
2707
2708 You can use the %l specifier in an alias definition to represent the
2708 You can use the %l specifier in an alias definition to represent the
2709 whole line when the alias is called. For example::
2709 whole line when the alias is called. For example::
2710
2710
2711 In [2]: alias bracket echo "Input in brackets: <%l>"
2711 In [2]: alias bracket echo "Input in brackets: <%l>"
2712 In [3]: bracket hello world
2712 In [3]: bracket hello world
2713 Input in brackets: <hello world>
2713 Input in brackets: <hello world>
2714
2714
2715 You can also define aliases with parameters using %s specifiers (one
2715 You can also define aliases with parameters using %s specifiers (one
2716 per parameter)::
2716 per parameter)::
2717
2717
2718 In [1]: alias parts echo first %s second %s
2718 In [1]: alias parts echo first %s second %s
2719 In [2]: %parts A B
2719 In [2]: %parts A B
2720 first A second B
2720 first A second B
2721 In [3]: %parts A
2721 In [3]: %parts A
2722 Incorrect number of arguments: 2 expected.
2722 Incorrect number of arguments: 2 expected.
2723 parts is an alias to: 'echo first %s second %s'
2723 parts is an alias to: 'echo first %s second %s'
2724
2724
2725 Note that %l and %s are mutually exclusive. You can only use one or
2725 Note that %l and %s are mutually exclusive. You can only use one or
2726 the other in your aliases.
2726 the other in your aliases.
2727
2727
2728 Aliases expand Python variables just like system calls using ! or !!
2728 Aliases expand Python variables just like system calls using ! or !!
2729 do: all expressions prefixed with '$' get expanded. For details of
2729 do: all expressions prefixed with '$' get expanded. For details of
2730 the semantic rules, see PEP-215:
2730 the semantic rules, see PEP-215:
2731 http://www.python.org/peps/pep-0215.html. This is the library used by
2731 http://www.python.org/peps/pep-0215.html. This is the library used by
2732 IPython for variable expansion. If you want to access a true shell
2732 IPython for variable expansion. If you want to access a true shell
2733 variable, an extra $ is necessary to prevent its expansion by
2733 variable, an extra $ is necessary to prevent its expansion by
2734 IPython::
2734 IPython::
2735
2735
2736 In [6]: alias show echo
2736 In [6]: alias show echo
2737 In [7]: PATH='A Python string'
2737 In [7]: PATH='A Python string'
2738 In [8]: show $PATH
2738 In [8]: show $PATH
2739 A Python string
2739 A Python string
2740 In [9]: show $$PATH
2740 In [9]: show $$PATH
2741 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2741 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2742
2742
2743 You can use the alias facility to acess all of $PATH. See the %rehash
2743 You can use the alias facility to acess all of $PATH. See the %rehash
2744 and %rehashx functions, which automatically create aliases for the
2744 and %rehashx functions, which automatically create aliases for the
2745 contents of your $PATH.
2745 contents of your $PATH.
2746
2746
2747 If called with no parameters, %alias prints the current alias table."""
2747 If called with no parameters, %alias prints the current alias table."""
2748
2748
2749 par = parameter_s.strip()
2749 par = parameter_s.strip()
2750 if not par:
2750 if not par:
2751 stored = self.db.get('stored_aliases', {} )
2751 stored = self.db.get('stored_aliases', {} )
2752 aliases = sorted(self.shell.alias_manager.aliases)
2752 aliases = sorted(self.shell.alias_manager.aliases)
2753 # for k, v in stored:
2753 # for k, v in stored:
2754 # atab.append(k, v[0])
2754 # atab.append(k, v[0])
2755
2755
2756 print "Total number of aliases:", len(aliases)
2756 print "Total number of aliases:", len(aliases)
2757 sys.stdout.flush()
2757 sys.stdout.flush()
2758 return aliases
2758 return aliases
2759
2759
2760 # Now try to define a new one
2760 # Now try to define a new one
2761 try:
2761 try:
2762 alias,cmd = par.split(None, 1)
2762 alias,cmd = par.split(None, 1)
2763 except:
2763 except:
2764 print oinspect.getdoc(self.magic_alias)
2764 print oinspect.getdoc(self.magic_alias)
2765 else:
2765 else:
2766 self.shell.alias_manager.soft_define_alias(alias, cmd)
2766 self.shell.alias_manager.soft_define_alias(alias, cmd)
2767 # end magic_alias
2767 # end magic_alias
2768
2768
2769 def magic_unalias(self, parameter_s = ''):
2769 def magic_unalias(self, parameter_s = ''):
2770 """Remove an alias"""
2770 """Remove an alias"""
2771
2771
2772 aname = parameter_s.strip()
2772 aname = parameter_s.strip()
2773 self.shell.alias_manager.undefine_alias(aname)
2773 self.shell.alias_manager.undefine_alias(aname)
2774 stored = self.db.get('stored_aliases', {} )
2774 stored = self.db.get('stored_aliases', {} )
2775 if aname in stored:
2775 if aname in stored:
2776 print "Removing %stored alias",aname
2776 print "Removing %stored alias",aname
2777 del stored[aname]
2777 del stored[aname]
2778 self.db['stored_aliases'] = stored
2778 self.db['stored_aliases'] = stored
2779
2779
2780 def magic_rehashx(self, parameter_s = ''):
2780 def magic_rehashx(self, parameter_s = ''):
2781 """Update the alias table with all executable files in $PATH.
2781 """Update the alias table with all executable files in $PATH.
2782
2782
2783 This version explicitly checks that every entry in $PATH is a file
2783 This version explicitly checks that every entry in $PATH is a file
2784 with execute access (os.X_OK), so it is much slower than %rehash.
2784 with execute access (os.X_OK), so it is much slower than %rehash.
2785
2785
2786 Under Windows, it checks executability as a match against a
2786 Under Windows, it checks executability as a match against a
2787 '|'-separated string of extensions, stored in the IPython config
2787 '|'-separated string of extensions, stored in the IPython config
2788 variable win_exec_ext. This defaults to 'exe|com|bat'.
2788 variable win_exec_ext. This defaults to 'exe|com|bat'.
2789
2789
2790 This function also resets the root module cache of module completer,
2790 This function also resets the root module cache of module completer,
2791 used on slow filesystems.
2791 used on slow filesystems.
2792 """
2792 """
2793 from IPython.core.alias import InvalidAliasError
2793 from IPython.core.alias import InvalidAliasError
2794
2794
2795 # for the benefit of module completer in ipy_completers.py
2795 # for the benefit of module completer in ipy_completers.py
2796 del self.shell.db['rootmodules']
2796 del self.shell.db['rootmodules']
2797
2797
2798 path = [os.path.abspath(os.path.expanduser(p)) for p in
2798 path = [os.path.abspath(os.path.expanduser(p)) for p in
2799 os.environ.get('PATH','').split(os.pathsep)]
2799 os.environ.get('PATH','').split(os.pathsep)]
2800 path = filter(os.path.isdir,path)
2800 path = filter(os.path.isdir,path)
2801
2801
2802 syscmdlist = []
2802 syscmdlist = []
2803 # Now define isexec in a cross platform manner.
2803 # Now define isexec in a cross platform manner.
2804 if os.name == 'posix':
2804 if os.name == 'posix':
2805 isexec = lambda fname:os.path.isfile(fname) and \
2805 isexec = lambda fname:os.path.isfile(fname) and \
2806 os.access(fname,os.X_OK)
2806 os.access(fname,os.X_OK)
2807 else:
2807 else:
2808 try:
2808 try:
2809 winext = os.environ['pathext'].replace(';','|').replace('.','')
2809 winext = os.environ['pathext'].replace(';','|').replace('.','')
2810 except KeyError:
2810 except KeyError:
2811 winext = 'exe|com|bat|py'
2811 winext = 'exe|com|bat|py'
2812 if 'py' not in winext:
2812 if 'py' not in winext:
2813 winext += '|py'
2813 winext += '|py'
2814 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2814 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2815 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2815 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2816 savedir = os.getcwdu()
2816 savedir = os.getcwdu()
2817
2817
2818 # Now walk the paths looking for executables to alias.
2818 # Now walk the paths looking for executables to alias.
2819 try:
2819 try:
2820 # write the whole loop for posix/Windows so we don't have an if in
2820 # write the whole loop for posix/Windows so we don't have an if in
2821 # the innermost part
2821 # the innermost part
2822 if os.name == 'posix':
2822 if os.name == 'posix':
2823 for pdir in path:
2823 for pdir in path:
2824 os.chdir(pdir)
2824 os.chdir(pdir)
2825 for ff in os.listdir(pdir):
2825 for ff in os.listdir(pdir):
2826 if isexec(ff):
2826 if isexec(ff):
2827 try:
2827 try:
2828 # Removes dots from the name since ipython
2828 # Removes dots from the name since ipython
2829 # will assume names with dots to be python.
2829 # will assume names with dots to be python.
2830 self.shell.alias_manager.define_alias(
2830 self.shell.alias_manager.define_alias(
2831 ff.replace('.',''), ff)
2831 ff.replace('.',''), ff)
2832 except InvalidAliasError:
2832 except InvalidAliasError:
2833 pass
2833 pass
2834 else:
2834 else:
2835 syscmdlist.append(ff)
2835 syscmdlist.append(ff)
2836 else:
2836 else:
2837 no_alias = self.shell.alias_manager.no_alias
2837 no_alias = self.shell.alias_manager.no_alias
2838 for pdir in path:
2838 for pdir in path:
2839 os.chdir(pdir)
2839 os.chdir(pdir)
2840 for ff in os.listdir(pdir):
2840 for ff in os.listdir(pdir):
2841 base, ext = os.path.splitext(ff)
2841 base, ext = os.path.splitext(ff)
2842 if isexec(ff) and base.lower() not in no_alias:
2842 if isexec(ff) and base.lower() not in no_alias:
2843 if ext.lower() == '.exe':
2843 if ext.lower() == '.exe':
2844 ff = base
2844 ff = base
2845 try:
2845 try:
2846 # Removes dots from the name since ipython
2846 # Removes dots from the name since ipython
2847 # will assume names with dots to be python.
2847 # will assume names with dots to be python.
2848 self.shell.alias_manager.define_alias(
2848 self.shell.alias_manager.define_alias(
2849 base.lower().replace('.',''), ff)
2849 base.lower().replace('.',''), ff)
2850 except InvalidAliasError:
2850 except InvalidAliasError:
2851 pass
2851 pass
2852 syscmdlist.append(ff)
2852 syscmdlist.append(ff)
2853 self.shell.db['syscmdlist'] = syscmdlist
2853 self.shell.db['syscmdlist'] = syscmdlist
2854 finally:
2854 finally:
2855 os.chdir(savedir)
2855 os.chdir(savedir)
2856
2856
2857 @skip_doctest
2857 @skip_doctest
2858 def magic_pwd(self, parameter_s = ''):
2858 def magic_pwd(self, parameter_s = ''):
2859 """Return the current working directory path.
2859 """Return the current working directory path.
2860
2860
2861 Examples
2861 Examples
2862 --------
2862 --------
2863 ::
2863 ::
2864
2864
2865 In [9]: pwd
2865 In [9]: pwd
2866 Out[9]: '/home/tsuser/sprint/ipython'
2866 Out[9]: '/home/tsuser/sprint/ipython'
2867 """
2867 """
2868 return os.getcwdu()
2868 return os.getcwdu()
2869
2869
2870 @skip_doctest
2870 @skip_doctest
2871 def magic_cd(self, parameter_s=''):
2871 def magic_cd(self, parameter_s=''):
2872 """Change the current working directory.
2872 """Change the current working directory.
2873
2873
2874 This command automatically maintains an internal list of directories
2874 This command automatically maintains an internal list of directories
2875 you visit during your IPython session, in the variable _dh. The
2875 you visit during your IPython session, in the variable _dh. The
2876 command %dhist shows this history nicely formatted. You can also
2876 command %dhist shows this history nicely formatted. You can also
2877 do 'cd -<tab>' to see directory history conveniently.
2877 do 'cd -<tab>' to see directory history conveniently.
2878
2878
2879 Usage:
2879 Usage:
2880
2880
2881 cd 'dir': changes to directory 'dir'.
2881 cd 'dir': changes to directory 'dir'.
2882
2882
2883 cd -: changes to the last visited directory.
2883 cd -: changes to the last visited directory.
2884
2884
2885 cd -<n>: changes to the n-th directory in the directory history.
2885 cd -<n>: changes to the n-th directory in the directory history.
2886
2886
2887 cd --foo: change to directory that matches 'foo' in history
2887 cd --foo: change to directory that matches 'foo' in history
2888
2888
2889 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2889 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2890 (note: cd <bookmark_name> is enough if there is no
2890 (note: cd <bookmark_name> is enough if there is no
2891 directory <bookmark_name>, but a bookmark with the name exists.)
2891 directory <bookmark_name>, but a bookmark with the name exists.)
2892 'cd -b <tab>' allows you to tab-complete bookmark names.
2892 'cd -b <tab>' allows you to tab-complete bookmark names.
2893
2893
2894 Options:
2894 Options:
2895
2895
2896 -q: quiet. Do not print the working directory after the cd command is
2896 -q: quiet. Do not print the working directory after the cd command is
2897 executed. By default IPython's cd command does print this directory,
2897 executed. By default IPython's cd command does print this directory,
2898 since the default prompts do not display path information.
2898 since the default prompts do not display path information.
2899
2899
2900 Note that !cd doesn't work for this purpose because the shell where
2900 Note that !cd doesn't work for this purpose because the shell where
2901 !command runs is immediately discarded after executing 'command'.
2901 !command runs is immediately discarded after executing 'command'.
2902
2902
2903 Examples
2903 Examples
2904 --------
2904 --------
2905 ::
2905 ::
2906
2906
2907 In [10]: cd parent/child
2907 In [10]: cd parent/child
2908 /home/tsuser/parent/child
2908 /home/tsuser/parent/child
2909 """
2909 """
2910
2910
2911 parameter_s = parameter_s.strip()
2911 parameter_s = parameter_s.strip()
2912 #bkms = self.shell.persist.get("bookmarks",{})
2912 #bkms = self.shell.persist.get("bookmarks",{})
2913
2913
2914 oldcwd = os.getcwdu()
2914 oldcwd = os.getcwdu()
2915 numcd = re.match(r'(-)(\d+)$',parameter_s)
2915 numcd = re.match(r'(-)(\d+)$',parameter_s)
2916 # jump in directory history by number
2916 # jump in directory history by number
2917 if numcd:
2917 if numcd:
2918 nn = int(numcd.group(2))
2918 nn = int(numcd.group(2))
2919 try:
2919 try:
2920 ps = self.shell.user_ns['_dh'][nn]
2920 ps = self.shell.user_ns['_dh'][nn]
2921 except IndexError:
2921 except IndexError:
2922 print 'The requested directory does not exist in history.'
2922 print 'The requested directory does not exist in history.'
2923 return
2923 return
2924 else:
2924 else:
2925 opts = {}
2925 opts = {}
2926 elif parameter_s.startswith('--'):
2926 elif parameter_s.startswith('--'):
2927 ps = None
2927 ps = None
2928 fallback = None
2928 fallback = None
2929 pat = parameter_s[2:]
2929 pat = parameter_s[2:]
2930 dh = self.shell.user_ns['_dh']
2930 dh = self.shell.user_ns['_dh']
2931 # first search only by basename (last component)
2931 # first search only by basename (last component)
2932 for ent in reversed(dh):
2932 for ent in reversed(dh):
2933 if pat in os.path.basename(ent) and os.path.isdir(ent):
2933 if pat in os.path.basename(ent) and os.path.isdir(ent):
2934 ps = ent
2934 ps = ent
2935 break
2935 break
2936
2936
2937 if fallback is None and pat in ent and os.path.isdir(ent):
2937 if fallback is None and pat in ent and os.path.isdir(ent):
2938 fallback = ent
2938 fallback = ent
2939
2939
2940 # if we have no last part match, pick the first full path match
2940 # if we have no last part match, pick the first full path match
2941 if ps is None:
2941 if ps is None:
2942 ps = fallback
2942 ps = fallback
2943
2943
2944 if ps is None:
2944 if ps is None:
2945 print "No matching entry in directory history"
2945 print "No matching entry in directory history"
2946 return
2946 return
2947 else:
2947 else:
2948 opts = {}
2948 opts = {}
2949
2949
2950
2950
2951 else:
2951 else:
2952 #turn all non-space-escaping backslashes to slashes,
2952 #turn all non-space-escaping backslashes to slashes,
2953 # for c:\windows\directory\names\
2953 # for c:\windows\directory\names\
2954 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2954 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2955 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2955 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2956 # jump to previous
2956 # jump to previous
2957 if ps == '-':
2957 if ps == '-':
2958 try:
2958 try:
2959 ps = self.shell.user_ns['_dh'][-2]
2959 ps = self.shell.user_ns['_dh'][-2]
2960 except IndexError:
2960 except IndexError:
2961 raise UsageError('%cd -: No previous directory to change to.')
2961 raise UsageError('%cd -: No previous directory to change to.')
2962 # jump to bookmark if needed
2962 # jump to bookmark if needed
2963 else:
2963 else:
2964 if not os.path.isdir(ps) or opts.has_key('b'):
2964 if not os.path.isdir(ps) or opts.has_key('b'):
2965 bkms = self.db.get('bookmarks', {})
2965 bkms = self.db.get('bookmarks', {})
2966
2966
2967 if bkms.has_key(ps):
2967 if bkms.has_key(ps):
2968 target = bkms[ps]
2968 target = bkms[ps]
2969 print '(bookmark:%s) -> %s' % (ps,target)
2969 print '(bookmark:%s) -> %s' % (ps,target)
2970 ps = target
2970 ps = target
2971 else:
2971 else:
2972 if opts.has_key('b'):
2972 if opts.has_key('b'):
2973 raise UsageError("Bookmark '%s' not found. "
2973 raise UsageError("Bookmark '%s' not found. "
2974 "Use '%%bookmark -l' to see your bookmarks." % ps)
2974 "Use '%%bookmark -l' to see your bookmarks." % ps)
2975
2975
2976 # strip extra quotes on Windows, because os.chdir doesn't like them
2976 # strip extra quotes on Windows, because os.chdir doesn't like them
2977 ps = unquote_filename(ps)
2977 ps = unquote_filename(ps)
2978 # at this point ps should point to the target dir
2978 # at this point ps should point to the target dir
2979 if ps:
2979 if ps:
2980 try:
2980 try:
2981 os.chdir(os.path.expanduser(ps))
2981 os.chdir(os.path.expanduser(ps))
2982 if hasattr(self.shell, 'term_title') and self.shell.term_title:
2982 if hasattr(self.shell, 'term_title') and self.shell.term_title:
2983 set_term_title('IPython: ' + abbrev_cwd())
2983 set_term_title('IPython: ' + abbrev_cwd())
2984 except OSError:
2984 except OSError:
2985 print sys.exc_info()[1]
2985 print sys.exc_info()[1]
2986 else:
2986 else:
2987 cwd = os.getcwdu()
2987 cwd = os.getcwdu()
2988 dhist = self.shell.user_ns['_dh']
2988 dhist = self.shell.user_ns['_dh']
2989 if oldcwd != cwd:
2989 if oldcwd != cwd:
2990 dhist.append(cwd)
2990 dhist.append(cwd)
2991 self.db['dhist'] = compress_dhist(dhist)[-100:]
2991 self.db['dhist'] = compress_dhist(dhist)[-100:]
2992
2992
2993 else:
2993 else:
2994 os.chdir(self.shell.home_dir)
2994 os.chdir(self.shell.home_dir)
2995 if hasattr(self.shell, 'term_title') and self.shell.term_title:
2995 if hasattr(self.shell, 'term_title') and self.shell.term_title:
2996 set_term_title('IPython: ' + '~')
2996 set_term_title('IPython: ' + '~')
2997 cwd = os.getcwdu()
2997 cwd = os.getcwdu()
2998 dhist = self.shell.user_ns['_dh']
2998 dhist = self.shell.user_ns['_dh']
2999
2999
3000 if oldcwd != cwd:
3000 if oldcwd != cwd:
3001 dhist.append(cwd)
3001 dhist.append(cwd)
3002 self.db['dhist'] = compress_dhist(dhist)[-100:]
3002 self.db['dhist'] = compress_dhist(dhist)[-100:]
3003 if not 'q' in opts and self.shell.user_ns['_dh']:
3003 if not 'q' in opts and self.shell.user_ns['_dh']:
3004 print self.shell.user_ns['_dh'][-1]
3004 print self.shell.user_ns['_dh'][-1]
3005
3005
3006
3006
3007 def magic_env(self, parameter_s=''):
3007 def magic_env(self, parameter_s=''):
3008 """List environment variables."""
3008 """List environment variables."""
3009
3009
3010 return dict(os.environ)
3010 return dict(os.environ)
3011
3011
3012 def magic_pushd(self, parameter_s=''):
3012 def magic_pushd(self, parameter_s=''):
3013 """Place the current dir on stack and change directory.
3013 """Place the current dir on stack and change directory.
3014
3014
3015 Usage:\\
3015 Usage:\\
3016 %pushd ['dirname']
3016 %pushd ['dirname']
3017 """
3017 """
3018
3018
3019 dir_s = self.shell.dir_stack
3019 dir_s = self.shell.dir_stack
3020 tgt = os.path.expanduser(unquote_filename(parameter_s))
3020 tgt = os.path.expanduser(unquote_filename(parameter_s))
3021 cwd = os.getcwdu().replace(self.home_dir,'~')
3021 cwd = os.getcwdu().replace(self.home_dir,'~')
3022 if tgt:
3022 if tgt:
3023 self.magic_cd(parameter_s)
3023 self.magic_cd(parameter_s)
3024 dir_s.insert(0,cwd)
3024 dir_s.insert(0,cwd)
3025 return self.magic_dirs()
3025 return self.magic_dirs()
3026
3026
3027 def magic_popd(self, parameter_s=''):
3027 def magic_popd(self, parameter_s=''):
3028 """Change to directory popped off the top of the stack.
3028 """Change to directory popped off the top of the stack.
3029 """
3029 """
3030 if not self.shell.dir_stack:
3030 if not self.shell.dir_stack:
3031 raise UsageError("%popd on empty stack")
3031 raise UsageError("%popd on empty stack")
3032 top = self.shell.dir_stack.pop(0)
3032 top = self.shell.dir_stack.pop(0)
3033 self.magic_cd(top)
3033 self.magic_cd(top)
3034 print "popd ->",top
3034 print "popd ->",top
3035
3035
3036 def magic_dirs(self, parameter_s=''):
3036 def magic_dirs(self, parameter_s=''):
3037 """Return the current directory stack."""
3037 """Return the current directory stack."""
3038
3038
3039 return self.shell.dir_stack
3039 return self.shell.dir_stack
3040
3040
3041 def magic_dhist(self, parameter_s=''):
3041 def magic_dhist(self, parameter_s=''):
3042 """Print your history of visited directories.
3042 """Print your history of visited directories.
3043
3043
3044 %dhist -> print full history\\
3044 %dhist -> print full history\\
3045 %dhist n -> print last n entries only\\
3045 %dhist n -> print last n entries only\\
3046 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
3046 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
3047
3047
3048 This history is automatically maintained by the %cd command, and
3048 This history is automatically maintained by the %cd command, and
3049 always available as the global list variable _dh. You can use %cd -<n>
3049 always available as the global list variable _dh. You can use %cd -<n>
3050 to go to directory number <n>.
3050 to go to directory number <n>.
3051
3051
3052 Note that most of time, you should view directory history by entering
3052 Note that most of time, you should view directory history by entering
3053 cd -<TAB>.
3053 cd -<TAB>.
3054
3054
3055 """
3055 """
3056
3056
3057 dh = self.shell.user_ns['_dh']
3057 dh = self.shell.user_ns['_dh']
3058 if parameter_s:
3058 if parameter_s:
3059 try:
3059 try:
3060 args = map(int,parameter_s.split())
3060 args = map(int,parameter_s.split())
3061 except:
3061 except:
3062 self.arg_err(Magic.magic_dhist)
3062 self.arg_err(Magic.magic_dhist)
3063 return
3063 return
3064 if len(args) == 1:
3064 if len(args) == 1:
3065 ini,fin = max(len(dh)-(args[0]),0),len(dh)
3065 ini,fin = max(len(dh)-(args[0]),0),len(dh)
3066 elif len(args) == 2:
3066 elif len(args) == 2:
3067 ini,fin = args
3067 ini,fin = args
3068 else:
3068 else:
3069 self.arg_err(Magic.magic_dhist)
3069 self.arg_err(Magic.magic_dhist)
3070 return
3070 return
3071 else:
3071 else:
3072 ini,fin = 0,len(dh)
3072 ini,fin = 0,len(dh)
3073 nlprint(dh,
3073 nlprint(dh,
3074 header = 'Directory history (kept in _dh)',
3074 header = 'Directory history (kept in _dh)',
3075 start=ini,stop=fin)
3075 start=ini,stop=fin)
3076
3076
3077 @skip_doctest
3077 @skip_doctest
3078 def magic_sc(self, parameter_s=''):
3078 def magic_sc(self, parameter_s=''):
3079 """Shell capture - execute a shell command and capture its output.
3079 """Shell capture - execute a shell command and capture its output.
3080
3080
3081 DEPRECATED. Suboptimal, retained for backwards compatibility.
3081 DEPRECATED. Suboptimal, retained for backwards compatibility.
3082
3082
3083 You should use the form 'var = !command' instead. Example:
3083 You should use the form 'var = !command' instead. Example:
3084
3084
3085 "%sc -l myfiles = ls ~" should now be written as
3085 "%sc -l myfiles = ls ~" should now be written as
3086
3086
3087 "myfiles = !ls ~"
3087 "myfiles = !ls ~"
3088
3088
3089 myfiles.s, myfiles.l and myfiles.n still apply as documented
3089 myfiles.s, myfiles.l and myfiles.n still apply as documented
3090 below.
3090 below.
3091
3091
3092 --
3092 --
3093 %sc [options] varname=command
3093 %sc [options] varname=command
3094
3094
3095 IPython will run the given command using commands.getoutput(), and
3095 IPython will run the given command using commands.getoutput(), and
3096 will then update the user's interactive namespace with a variable
3096 will then update the user's interactive namespace with a variable
3097 called varname, containing the value of the call. Your command can
3097 called varname, containing the value of the call. Your command can
3098 contain shell wildcards, pipes, etc.
3098 contain shell wildcards, pipes, etc.
3099
3099
3100 The '=' sign in the syntax is mandatory, and the variable name you
3100 The '=' sign in the syntax is mandatory, and the variable name you
3101 supply must follow Python's standard conventions for valid names.
3101 supply must follow Python's standard conventions for valid names.
3102
3102
3103 (A special format without variable name exists for internal use)
3103 (A special format without variable name exists for internal use)
3104
3104
3105 Options:
3105 Options:
3106
3106
3107 -l: list output. Split the output on newlines into a list before
3107 -l: list output. Split the output on newlines into a list before
3108 assigning it to the given variable. By default the output is stored
3108 assigning it to the given variable. By default the output is stored
3109 as a single string.
3109 as a single string.
3110
3110
3111 -v: verbose. Print the contents of the variable.
3111 -v: verbose. Print the contents of the variable.
3112
3112
3113 In most cases you should not need to split as a list, because the
3113 In most cases you should not need to split as a list, because the
3114 returned value is a special type of string which can automatically
3114 returned value is a special type of string which can automatically
3115 provide its contents either as a list (split on newlines) or as a
3115 provide its contents either as a list (split on newlines) or as a
3116 space-separated string. These are convenient, respectively, either
3116 space-separated string. These are convenient, respectively, either
3117 for sequential processing or to be passed to a shell command.
3117 for sequential processing or to be passed to a shell command.
3118
3118
3119 For example::
3119 For example::
3120
3120
3121 # Capture into variable a
3121 # Capture into variable a
3122 In [1]: sc a=ls *py
3122 In [1]: sc a=ls *py
3123
3123
3124 # a is a string with embedded newlines
3124 # a is a string with embedded newlines
3125 In [2]: a
3125 In [2]: a
3126 Out[2]: 'setup.py\\nwin32_manual_post_install.py'
3126 Out[2]: 'setup.py\\nwin32_manual_post_install.py'
3127
3127
3128 # which can be seen as a list:
3128 # which can be seen as a list:
3129 In [3]: a.l
3129 In [3]: a.l
3130 Out[3]: ['setup.py', 'win32_manual_post_install.py']
3130 Out[3]: ['setup.py', 'win32_manual_post_install.py']
3131
3131
3132 # or as a whitespace-separated string:
3132 # or as a whitespace-separated string:
3133 In [4]: a.s
3133 In [4]: a.s
3134 Out[4]: 'setup.py win32_manual_post_install.py'
3134 Out[4]: 'setup.py win32_manual_post_install.py'
3135
3135
3136 # a.s is useful to pass as a single command line:
3136 # a.s is useful to pass as a single command line:
3137 In [5]: !wc -l $a.s
3137 In [5]: !wc -l $a.s
3138 146 setup.py
3138 146 setup.py
3139 130 win32_manual_post_install.py
3139 130 win32_manual_post_install.py
3140 276 total
3140 276 total
3141
3141
3142 # while the list form is useful to loop over:
3142 # while the list form is useful to loop over:
3143 In [6]: for f in a.l:
3143 In [6]: for f in a.l:
3144 ...: !wc -l $f
3144 ...: !wc -l $f
3145 ...:
3145 ...:
3146 146 setup.py
3146 146 setup.py
3147 130 win32_manual_post_install.py
3147 130 win32_manual_post_install.py
3148
3148
3149 Similarly, the lists returned by the -l option are also special, in
3149 Similarly, the lists returned by the -l option are also special, in
3150 the sense that you can equally invoke the .s attribute on them to
3150 the sense that you can equally invoke the .s attribute on them to
3151 automatically get a whitespace-separated string from their contents::
3151 automatically get a whitespace-separated string from their contents::
3152
3152
3153 In [7]: sc -l b=ls *py
3153 In [7]: sc -l b=ls *py
3154
3154
3155 In [8]: b
3155 In [8]: b
3156 Out[8]: ['setup.py', 'win32_manual_post_install.py']
3156 Out[8]: ['setup.py', 'win32_manual_post_install.py']
3157
3157
3158 In [9]: b.s
3158 In [9]: b.s
3159 Out[9]: 'setup.py win32_manual_post_install.py'
3159 Out[9]: 'setup.py win32_manual_post_install.py'
3160
3160
3161 In summary, both the lists and strings used for output capture have
3161 In summary, both the lists and strings used for output capture have
3162 the following special attributes::
3162 the following special attributes::
3163
3163
3164 .l (or .list) : value as list.
3164 .l (or .list) : value as list.
3165 .n (or .nlstr): value as newline-separated string.
3165 .n (or .nlstr): value as newline-separated string.
3166 .s (or .spstr): value as space-separated string.
3166 .s (or .spstr): value as space-separated string.
3167 """
3167 """
3168
3168
3169 opts,args = self.parse_options(parameter_s,'lv')
3169 opts,args = self.parse_options(parameter_s,'lv')
3170 # Try to get a variable name and command to run
3170 # Try to get a variable name and command to run
3171 try:
3171 try:
3172 # the variable name must be obtained from the parse_options
3172 # the variable name must be obtained from the parse_options
3173 # output, which uses shlex.split to strip options out.
3173 # output, which uses shlex.split to strip options out.
3174 var,_ = args.split('=',1)
3174 var,_ = args.split('=',1)
3175 var = var.strip()
3175 var = var.strip()
3176 # But the command has to be extracted from the original input
3176 # But the command has to be extracted from the original input
3177 # parameter_s, not on what parse_options returns, to avoid the
3177 # parameter_s, not on what parse_options returns, to avoid the
3178 # quote stripping which shlex.split performs on it.
3178 # quote stripping which shlex.split performs on it.
3179 _,cmd = parameter_s.split('=',1)
3179 _,cmd = parameter_s.split('=',1)
3180 except ValueError:
3180 except ValueError:
3181 var,cmd = '',''
3181 var,cmd = '',''
3182 # If all looks ok, proceed
3182 # If all looks ok, proceed
3183 split = 'l' in opts
3183 split = 'l' in opts
3184 out = self.shell.getoutput(cmd, split=split)
3184 out = self.shell.getoutput(cmd, split=split)
3185 if opts.has_key('v'):
3185 if opts.has_key('v'):
3186 print '%s ==\n%s' % (var,pformat(out))
3186 print '%s ==\n%s' % (var,pformat(out))
3187 if var:
3187 if var:
3188 self.shell.user_ns.update({var:out})
3188 self.shell.user_ns.update({var:out})
3189 else:
3189 else:
3190 return out
3190 return out
3191
3191
3192 def magic_sx(self, parameter_s=''):
3192 def magic_sx(self, parameter_s=''):
3193 """Shell execute - run a shell command and capture its output.
3193 """Shell execute - run a shell command and capture its output.
3194
3194
3195 %sx command
3195 %sx command
3196
3196
3197 IPython will run the given command using commands.getoutput(), and
3197 IPython will run the given command using commands.getoutput(), and
3198 return the result formatted as a list (split on '\\n'). Since the
3198 return the result formatted as a list (split on '\\n'). Since the
3199 output is _returned_, it will be stored in ipython's regular output
3199 output is _returned_, it will be stored in ipython's regular output
3200 cache Out[N] and in the '_N' automatic variables.
3200 cache Out[N] and in the '_N' automatic variables.
3201
3201
3202 Notes:
3202 Notes:
3203
3203
3204 1) If an input line begins with '!!', then %sx is automatically
3204 1) If an input line begins with '!!', then %sx is automatically
3205 invoked. That is, while::
3205 invoked. That is, while::
3206
3206
3207 !ls
3207 !ls
3208
3208
3209 causes ipython to simply issue system('ls'), typing::
3209 causes ipython to simply issue system('ls'), typing::
3210
3210
3211 !!ls
3211 !!ls
3212
3212
3213 is a shorthand equivalent to::
3213 is a shorthand equivalent to::
3214
3214
3215 %sx ls
3215 %sx ls
3216
3216
3217 2) %sx differs from %sc in that %sx automatically splits into a list,
3217 2) %sx differs from %sc in that %sx automatically splits into a list,
3218 like '%sc -l'. The reason for this is to make it as easy as possible
3218 like '%sc -l'. The reason for this is to make it as easy as possible
3219 to process line-oriented shell output via further python commands.
3219 to process line-oriented shell output via further python commands.
3220 %sc is meant to provide much finer control, but requires more
3220 %sc is meant to provide much finer control, but requires more
3221 typing.
3221 typing.
3222
3222
3223 3) Just like %sc -l, this is a list with special attributes:
3223 3) Just like %sc -l, this is a list with special attributes:
3224 ::
3224 ::
3225
3225
3226 .l (or .list) : value as list.
3226 .l (or .list) : value as list.
3227 .n (or .nlstr): value as newline-separated string.
3227 .n (or .nlstr): value as newline-separated string.
3228 .s (or .spstr): value as whitespace-separated string.
3228 .s (or .spstr): value as whitespace-separated string.
3229
3229
3230 This is very useful when trying to use such lists as arguments to
3230 This is very useful when trying to use such lists as arguments to
3231 system commands."""
3231 system commands."""
3232
3232
3233 if parameter_s:
3233 if parameter_s:
3234 return self.shell.getoutput(parameter_s)
3234 return self.shell.getoutput(parameter_s)
3235
3235
3236
3236
3237 def magic_bookmark(self, parameter_s=''):
3237 def magic_bookmark(self, parameter_s=''):
3238 """Manage IPython's bookmark system.
3238 """Manage IPython's bookmark system.
3239
3239
3240 %bookmark <name> - set bookmark to current dir
3240 %bookmark <name> - set bookmark to current dir
3241 %bookmark <name> <dir> - set bookmark to <dir>
3241 %bookmark <name> <dir> - set bookmark to <dir>
3242 %bookmark -l - list all bookmarks
3242 %bookmark -l - list all bookmarks
3243 %bookmark -d <name> - remove bookmark
3243 %bookmark -d <name> - remove bookmark
3244 %bookmark -r - remove all bookmarks
3244 %bookmark -r - remove all bookmarks
3245
3245
3246 You can later on access a bookmarked folder with::
3246 You can later on access a bookmarked folder with::
3247
3247
3248 %cd -b <name>
3248 %cd -b <name>
3249
3249
3250 or simply '%cd <name>' if there is no directory called <name> AND
3250 or simply '%cd <name>' if there is no directory called <name> AND
3251 there is such a bookmark defined.
3251 there is such a bookmark defined.
3252
3252
3253 Your bookmarks persist through IPython sessions, but they are
3253 Your bookmarks persist through IPython sessions, but they are
3254 associated with each profile."""
3254 associated with each profile."""
3255
3255
3256 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3256 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3257 if len(args) > 2:
3257 if len(args) > 2:
3258 raise UsageError("%bookmark: too many arguments")
3258 raise UsageError("%bookmark: too many arguments")
3259
3259
3260 bkms = self.db.get('bookmarks',{})
3260 bkms = self.db.get('bookmarks',{})
3261
3261
3262 if opts.has_key('d'):
3262 if opts.has_key('d'):
3263 try:
3263 try:
3264 todel = args[0]
3264 todel = args[0]
3265 except IndexError:
3265 except IndexError:
3266 raise UsageError(
3266 raise UsageError(
3267 "%bookmark -d: must provide a bookmark to delete")
3267 "%bookmark -d: must provide a bookmark to delete")
3268 else:
3268 else:
3269 try:
3269 try:
3270 del bkms[todel]
3270 del bkms[todel]
3271 except KeyError:
3271 except KeyError:
3272 raise UsageError(
3272 raise UsageError(
3273 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3273 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3274
3274
3275 elif opts.has_key('r'):
3275 elif opts.has_key('r'):
3276 bkms = {}
3276 bkms = {}
3277 elif opts.has_key('l'):
3277 elif opts.has_key('l'):
3278 bks = bkms.keys()
3278 bks = bkms.keys()
3279 bks.sort()
3279 bks.sort()
3280 if bks:
3280 if bks:
3281 size = max(map(len,bks))
3281 size = max(map(len,bks))
3282 else:
3282 else:
3283 size = 0
3283 size = 0
3284 fmt = '%-'+str(size)+'s -> %s'
3284 fmt = '%-'+str(size)+'s -> %s'
3285 print 'Current bookmarks:'
3285 print 'Current bookmarks:'
3286 for bk in bks:
3286 for bk in bks:
3287 print fmt % (bk,bkms[bk])
3287 print fmt % (bk,bkms[bk])
3288 else:
3288 else:
3289 if not args:
3289 if not args:
3290 raise UsageError("%bookmark: You must specify the bookmark name")
3290 raise UsageError("%bookmark: You must specify the bookmark name")
3291 elif len(args)==1:
3291 elif len(args)==1:
3292 bkms[args[0]] = os.getcwdu()
3292 bkms[args[0]] = os.getcwdu()
3293 elif len(args)==2:
3293 elif len(args)==2:
3294 bkms[args[0]] = args[1]
3294 bkms[args[0]] = args[1]
3295 self.db['bookmarks'] = bkms
3295 self.db['bookmarks'] = bkms
3296
3296
3297 def magic_pycat(self, parameter_s=''):
3297 def magic_pycat(self, parameter_s=''):
3298 """Show a syntax-highlighted file through a pager.
3298 """Show a syntax-highlighted file through a pager.
3299
3299
3300 This magic is similar to the cat utility, but it will assume the file
3300 This magic is similar to the cat utility, but it will assume the file
3301 to be Python source and will show it with syntax highlighting. """
3301 to be Python source and will show it with syntax highlighting. """
3302
3302
3303 try:
3303 try:
3304 filename = get_py_filename(parameter_s)
3304 filename = get_py_filename(parameter_s)
3305 cont = file_read(filename)
3305 cont = file_read(filename)
3306 except IOError:
3306 except IOError:
3307 try:
3307 try:
3308 cont = eval(parameter_s,self.user_ns)
3308 cont = eval(parameter_s,self.user_ns)
3309 except NameError:
3309 except NameError:
3310 cont = None
3310 cont = None
3311 if cont is None:
3311 if cont is None:
3312 print "Error: no such file or variable"
3312 print "Error: no such file or variable"
3313 return
3313 return
3314
3314
3315 page.page(self.shell.pycolorize(cont))
3315 page.page(self.shell.pycolorize(cont))
3316
3316
3317 def magic_quickref(self,arg):
3317 def magic_quickref(self,arg):
3318 """ Show a quick reference sheet """
3318 """ Show a quick reference sheet """
3319 import IPython.core.usage
3319 import IPython.core.usage
3320 qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
3320 qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
3321
3321
3322 page.page(qr)
3322 page.page(qr)
3323
3323
3324 def magic_doctest_mode(self,parameter_s=''):
3324 def magic_doctest_mode(self,parameter_s=''):
3325 """Toggle doctest mode on and off.
3325 """Toggle doctest mode on and off.
3326
3326
3327 This mode is intended to make IPython behave as much as possible like a
3327 This mode is intended to make IPython behave as much as possible like a
3328 plain Python shell, from the perspective of how its prompts, exceptions
3328 plain Python shell, from the perspective of how its prompts, exceptions
3329 and output look. This makes it easy to copy and paste parts of a
3329 and output look. This makes it easy to copy and paste parts of a
3330 session into doctests. It does so by:
3330 session into doctests. It does so by:
3331
3331
3332 - Changing the prompts to the classic ``>>>`` ones.
3332 - Changing the prompts to the classic ``>>>`` ones.
3333 - Changing the exception reporting mode to 'Plain'.
3333 - Changing the exception reporting mode to 'Plain'.
3334 - Disabling pretty-printing of output.
3334 - Disabling pretty-printing of output.
3335
3335
3336 Note that IPython also supports the pasting of code snippets that have
3336 Note that IPython also supports the pasting of code snippets that have
3337 leading '>>>' and '...' prompts in them. This means that you can paste
3337 leading '>>>' and '...' prompts in them. This means that you can paste
3338 doctests from files or docstrings (even if they have leading
3338 doctests from files or docstrings (even if they have leading
3339 whitespace), and the code will execute correctly. You can then use
3339 whitespace), and the code will execute correctly. You can then use
3340 '%history -t' to see the translated history; this will give you the
3340 '%history -t' to see the translated history; this will give you the
3341 input after removal of all the leading prompts and whitespace, which
3341 input after removal of all the leading prompts and whitespace, which
3342 can be pasted back into an editor.
3342 can be pasted back into an editor.
3343
3343
3344 With these features, you can switch into this mode easily whenever you
3344 With these features, you can switch into this mode easily whenever you
3345 need to do testing and changes to doctests, without having to leave
3345 need to do testing and changes to doctests, without having to leave
3346 your existing IPython session.
3346 your existing IPython session.
3347 """
3347 """
3348
3348
3349 from IPython.utils.ipstruct import Struct
3349 from IPython.utils.ipstruct import Struct
3350
3350
3351 # Shorthands
3351 # Shorthands
3352 shell = self.shell
3352 shell = self.shell
3353 pm = shell.prompt_manager
3353 pm = shell.prompt_manager
3354 meta = shell.meta
3354 meta = shell.meta
3355 disp_formatter = self.shell.display_formatter
3355 disp_formatter = self.shell.display_formatter
3356 ptformatter = disp_formatter.formatters['text/plain']
3356 ptformatter = disp_formatter.formatters['text/plain']
3357 # dstore is a data store kept in the instance metadata bag to track any
3357 # dstore is a data store kept in the instance metadata bag to track any
3358 # changes we make, so we can undo them later.
3358 # changes we make, so we can undo them later.
3359 dstore = meta.setdefault('doctest_mode',Struct())
3359 dstore = meta.setdefault('doctest_mode',Struct())
3360 save_dstore = dstore.setdefault
3360 save_dstore = dstore.setdefault
3361
3361
3362 # save a few values we'll need to recover later
3362 # save a few values we'll need to recover later
3363 mode = save_dstore('mode',False)
3363 mode = save_dstore('mode',False)
3364 save_dstore('rc_pprint',ptformatter.pprint)
3364 save_dstore('rc_pprint',ptformatter.pprint)
3365 save_dstore('xmode',shell.InteractiveTB.mode)
3365 save_dstore('xmode',shell.InteractiveTB.mode)
3366 save_dstore('rc_separate_out',shell.separate_out)
3366 save_dstore('rc_separate_out',shell.separate_out)
3367 save_dstore('rc_separate_out2',shell.separate_out2)
3367 save_dstore('rc_separate_out2',shell.separate_out2)
3368 save_dstore('rc_prompts_pad_left',pm.justify)
3368 save_dstore('rc_prompts_pad_left',pm.justify)
3369 save_dstore('rc_separate_in',shell.separate_in)
3369 save_dstore('rc_separate_in',shell.separate_in)
3370 save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
3370 save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
3371 save_dstore('prompt_templates',(pm.in_template, pm.in2_template, pm.out_template))
3371 save_dstore('prompt_templates',(pm.in_template, pm.in2_template, pm.out_template))
3372
3372
3373 if mode == False:
3373 if mode == False:
3374 # turn on
3374 # turn on
3375 pm.in_template = '>>> '
3375 pm.in_template = '>>> '
3376 pm.in2_template = '... '
3376 pm.in2_template = '... '
3377 pm.out_template = ''
3377 pm.out_template = ''
3378
3378
3379 # Prompt separators like plain python
3379 # Prompt separators like plain python
3380 shell.separate_in = ''
3380 shell.separate_in = ''
3381 shell.separate_out = ''
3381 shell.separate_out = ''
3382 shell.separate_out2 = ''
3382 shell.separate_out2 = ''
3383
3383
3384 pm.justify = False
3384 pm.justify = False
3385
3385
3386 ptformatter.pprint = False
3386 ptformatter.pprint = False
3387 disp_formatter.plain_text_only = True
3387 disp_formatter.plain_text_only = True
3388
3388
3389 shell.magic_xmode('Plain')
3389 shell.magic_xmode('Plain')
3390 else:
3390 else:
3391 # turn off
3391 # turn off
3392 pm.in_template, pm.in2_template, pm.out_template = dstore.prompt_templates
3392 pm.in_template, pm.in2_template, pm.out_template = dstore.prompt_templates
3393
3393
3394 shell.separate_in = dstore.rc_separate_in
3394 shell.separate_in = dstore.rc_separate_in
3395
3395
3396 shell.separate_out = dstore.rc_separate_out
3396 shell.separate_out = dstore.rc_separate_out
3397 shell.separate_out2 = dstore.rc_separate_out2
3397 shell.separate_out2 = dstore.rc_separate_out2
3398
3398
3399 pm.justify = dstore.rc_prompts_pad_left
3399 pm.justify = dstore.rc_prompts_pad_left
3400
3400
3401 ptformatter.pprint = dstore.rc_pprint
3401 ptformatter.pprint = dstore.rc_pprint
3402 disp_formatter.plain_text_only = dstore.rc_plain_text_only
3402 disp_formatter.plain_text_only = dstore.rc_plain_text_only
3403
3403
3404 shell.magic_xmode(dstore.xmode)
3404 shell.magic_xmode(dstore.xmode)
3405
3405
3406 # Store new mode and inform
3406 # Store new mode and inform
3407 dstore.mode = bool(1-int(mode))
3407 dstore.mode = bool(1-int(mode))
3408 mode_label = ['OFF','ON'][dstore.mode]
3408 mode_label = ['OFF','ON'][dstore.mode]
3409 print 'Doctest mode is:', mode_label
3409 print 'Doctest mode is:', mode_label
3410
3410
3411 def magic_gui(self, parameter_s=''):
3411 def magic_gui(self, parameter_s=''):
3412 """Enable or disable IPython GUI event loop integration.
3412 """Enable or disable IPython GUI event loop integration.
3413
3413
3414 %gui [GUINAME]
3414 %gui [GUINAME]
3415
3415
3416 This magic replaces IPython's threaded shells that were activated
3416 This magic replaces IPython's threaded shells that were activated
3417 using the (pylab/wthread/etc.) command line flags. GUI toolkits
3417 using the (pylab/wthread/etc.) command line flags. GUI toolkits
3418 can now be enabled at runtime and keyboard
3418 can now be enabled at runtime and keyboard
3419 interrupts should work without any problems. The following toolkits
3419 interrupts should work without any problems. The following toolkits
3420 are supported: wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::
3420 are supported: wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::
3421
3421
3422 %gui wx # enable wxPython event loop integration
3422 %gui wx # enable wxPython event loop integration
3423 %gui qt4|qt # enable PyQt4 event loop integration
3423 %gui qt4|qt # enable PyQt4 event loop integration
3424 %gui gtk # enable PyGTK event loop integration
3424 %gui gtk # enable PyGTK event loop integration
3425 %gui gtk3 # enable Gtk3 event loop integration
3425 %gui gtk3 # enable Gtk3 event loop integration
3426 %gui tk # enable Tk event loop integration
3426 %gui tk # enable Tk event loop integration
3427 %gui OSX # enable Cocoa event loop integration
3427 %gui OSX # enable Cocoa event loop integration
3428 # (requires %matplotlib 1.1)
3428 # (requires %matplotlib 1.1)
3429 %gui # disable all event loop integration
3429 %gui # disable all event loop integration
3430
3430
3431 WARNING: after any of these has been called you can simply create
3431 WARNING: after any of these has been called you can simply create
3432 an application object, but DO NOT start the event loop yourself, as
3432 an application object, but DO NOT start the event loop yourself, as
3433 we have already handled that.
3433 we have already handled that.
3434 """
3434 """
3435 opts, arg = self.parse_options(parameter_s, '')
3435 opts, arg = self.parse_options(parameter_s, '')
3436 if arg=='': arg = None
3436 if arg=='': arg = None
3437 try:
3437 try:
3438 return self.enable_gui(arg)
3438 return self.enable_gui(arg)
3439 except Exception as e:
3439 except Exception as e:
3440 # print simple error message, rather than traceback if we can't
3440 # print simple error message, rather than traceback if we can't
3441 # hook up the GUI
3441 # hook up the GUI
3442 error(str(e))
3442 error(str(e))
3443
3443
3444 def magic_install_ext(self, parameter_s):
3444 def magic_install_ext(self, parameter_s):
3445 """Download and install an extension from a URL, e.g.::
3445 """Download and install an extension from a URL, e.g.::
3446
3446
3447 %install_ext https://bitbucket.org/birkenfeld/ipython-physics/raw/d1310a2ab15d/physics.py
3447 %install_ext https://bitbucket.org/birkenfeld/ipython-physics/raw/d1310a2ab15d/physics.py
3448
3448
3449 The URL should point to an importable Python module - either a .py file
3449 The URL should point to an importable Python module - either a .py file
3450 or a .zip file.
3450 or a .zip file.
3451
3451
3452 Parameters:
3452 Parameters:
3453
3453
3454 -n filename : Specify a name for the file, rather than taking it from
3454 -n filename : Specify a name for the file, rather than taking it from
3455 the URL.
3455 the URL.
3456 """
3456 """
3457 opts, args = self.parse_options(parameter_s, 'n:')
3457 opts, args = self.parse_options(parameter_s, 'n:')
3458 try:
3458 try:
3459 filename = self.extension_manager.install_extension(args, opts.get('n'))
3459 filename = self.extension_manager.install_extension(args, opts.get('n'))
3460 except ValueError as e:
3460 except ValueError as e:
3461 print e
3461 print e
3462 return
3462 return
3463
3463
3464 filename = os.path.basename(filename)
3464 filename = os.path.basename(filename)
3465 print "Installed %s. To use it, type:" % filename
3465 print "Installed %s. To use it, type:" % filename
3466 print " %%load_ext %s" % os.path.splitext(filename)[0]
3466 print " %%load_ext %s" % os.path.splitext(filename)[0]
3467
3467
3468
3468
3469 def magic_load_ext(self, module_str):
3469 def magic_load_ext(self, module_str):
3470 """Load an IPython extension by its module name."""
3470 """Load an IPython extension by its module name."""
3471 return self.extension_manager.load_extension(module_str)
3471 return self.extension_manager.load_extension(module_str)
3472
3472
3473 def magic_unload_ext(self, module_str):
3473 def magic_unload_ext(self, module_str):
3474 """Unload an IPython extension by its module name."""
3474 """Unload an IPython extension by its module name."""
3475 self.extension_manager.unload_extension(module_str)
3475 self.extension_manager.unload_extension(module_str)
3476
3476
3477 def magic_reload_ext(self, module_str):
3477 def magic_reload_ext(self, module_str):
3478 """Reload an IPython extension by its module name."""
3478 """Reload an IPython extension by its module name."""
3479 self.extension_manager.reload_extension(module_str)
3479 self.extension_manager.reload_extension(module_str)
3480
3480
3481 def magic_install_profiles(self, s):
3481 def magic_install_profiles(self, s):
3482 """%install_profiles has been deprecated."""
3482 """%install_profiles has been deprecated."""
3483 print '\n'.join([
3483 print '\n'.join([
3484 "%install_profiles has been deprecated.",
3484 "%install_profiles has been deprecated.",
3485 "Use `ipython profile list` to view available profiles.",
3485 "Use `ipython profile list` to view available profiles.",
3486 "Requesting a profile with `ipython profile create <name>`",
3486 "Requesting a profile with `ipython profile create <name>`",
3487 "or `ipython --profile=<name>` will start with the bundled",
3487 "or `ipython --profile=<name>` will start with the bundled",
3488 "profile of that name if it exists."
3488 "profile of that name if it exists."
3489 ])
3489 ])
3490
3490
3491 def magic_install_default_config(self, s):
3491 def magic_install_default_config(self, s):
3492 """%install_default_config has been deprecated."""
3492 """%install_default_config has been deprecated."""
3493 print '\n'.join([
3493 print '\n'.join([
3494 "%install_default_config has been deprecated.",
3494 "%install_default_config has been deprecated.",
3495 "Use `ipython profile create <name>` to initialize a profile",
3495 "Use `ipython profile create <name>` to initialize a profile",
3496 "with the default config files.",
3496 "with the default config files.",
3497 "Add `--reset` to overwrite already existing config files with defaults."
3497 "Add `--reset` to overwrite already existing config files with defaults."
3498 ])
3498 ])
3499
3499
3500 # Pylab support: simple wrappers that activate pylab, load gui input
3500 # Pylab support: simple wrappers that activate pylab, load gui input
3501 # handling and modify slightly %run
3501 # handling and modify slightly %run
3502
3502
3503 @skip_doctest
3503 @skip_doctest
3504 def _pylab_magic_run(self, parameter_s=''):
3504 def _pylab_magic_run(self, parameter_s=''):
3505 Magic.magic_run(self, parameter_s,
3505 Magic.magic_run(self, parameter_s,
3506 runner=mpl_runner(self.shell.safe_execfile))
3506 runner=mpl_runner(self.shell.safe_execfile))
3507
3507
3508 _pylab_magic_run.__doc__ = magic_run.__doc__
3508 _pylab_magic_run.__doc__ = magic_run.__doc__
3509
3509
3510 @skip_doctest
3510 @skip_doctest
3511 def magic_pylab(self, s):
3511 def magic_pylab(self, s):
3512 """Load numpy and matplotlib to work interactively.
3512 """Load numpy and matplotlib to work interactively.
3513
3513
3514 %pylab [GUINAME]
3514 %pylab [GUINAME]
3515
3515
3516 This function lets you activate pylab (matplotlib, numpy and
3516 This function lets you activate pylab (matplotlib, numpy and
3517 interactive support) at any point during an IPython session.
3517 interactive support) at any point during an IPython session.
3518
3518
3519 It will import at the top level numpy as np, pyplot as plt, matplotlib,
3519 It will import at the top level numpy as np, pyplot as plt, matplotlib,
3520 pylab and mlab, as well as all names from numpy and pylab.
3520 pylab and mlab, as well as all names from numpy and pylab.
3521
3521
3522 If you are using the inline matplotlib backend for embedded figures,
3522 If you are using the inline matplotlib backend for embedded figures,
3523 you can adjust its behavior via the %config magic::
3523 you can adjust its behavior via the %config magic::
3524
3524
3525 # enable SVG figures, necessary for SVG+XHTML export in the qtconsole
3525 # enable SVG figures, necessary for SVG+XHTML export in the qtconsole
3526 In [1]: %config InlineBackend.figure_format = 'svg'
3526 In [1]: %config InlineBackend.figure_format = 'svg'
3527
3527
3528 # change the behavior of closing all figures at the end of each
3528 # change the behavior of closing all figures at the end of each
3529 # execution (cell), or allowing reuse of active figures across
3529 # execution (cell), or allowing reuse of active figures across
3530 # cells:
3530 # cells:
3531 In [2]: %config InlineBackend.close_figures = False
3531 In [2]: %config InlineBackend.close_figures = False
3532
3532
3533 Parameters
3533 Parameters
3534 ----------
3534 ----------
3535 guiname : optional
3535 guiname : optional
3536 One of the valid arguments to the %gui magic ('qt', 'wx', 'gtk',
3536 One of the valid arguments to the %gui magic ('qt', 'wx', 'gtk',
3537 'osx' or 'tk'). If given, the corresponding Matplotlib backend is
3537 'osx' or 'tk'). If given, the corresponding Matplotlib backend is
3538 used, otherwise matplotlib's default (which you can override in your
3538 used, otherwise matplotlib's default (which you can override in your
3539 matplotlib config file) is used.
3539 matplotlib config file) is used.
3540
3540
3541 Examples
3541 Examples
3542 --------
3542 --------
3543 In this case, where the MPL default is TkAgg::
3543 In this case, where the MPL default is TkAgg::
3544
3544
3545 In [2]: %pylab
3545 In [2]: %pylab
3546
3546
3547 Welcome to pylab, a matplotlib-based Python environment.
3547 Welcome to pylab, a matplotlib-based Python environment.
3548 Backend in use: TkAgg
3548 Backend in use: TkAgg
3549 For more information, type 'help(pylab)'.
3549 For more information, type 'help(pylab)'.
3550
3550
3551 But you can explicitly request a different backend::
3551 But you can explicitly request a different backend::
3552
3552
3553 In [3]: %pylab qt
3553 In [3]: %pylab qt
3554
3554
3555 Welcome to pylab, a matplotlib-based Python environment.
3555 Welcome to pylab, a matplotlib-based Python environment.
3556 Backend in use: Qt4Agg
3556 Backend in use: Qt4Agg
3557 For more information, type 'help(pylab)'.
3557 For more information, type 'help(pylab)'.
3558 """
3558 """
3559
3559
3560 if Application.initialized():
3560 if Application.initialized():
3561 app = Application.instance()
3561 app = Application.instance()
3562 try:
3562 try:
3563 import_all_status = app.pylab_import_all
3563 import_all_status = app.pylab_import_all
3564 except AttributeError:
3564 except AttributeError:
3565 import_all_status = True
3565 import_all_status = True
3566 else:
3566 else:
3567 import_all_status = True
3567 import_all_status = True
3568
3568
3569 self.shell.enable_pylab(s, import_all=import_all_status)
3569 self.shell.enable_pylab(s, import_all=import_all_status)
3570
3570
3571 def magic_tb(self, s):
3571 def magic_tb(self, s):
3572 """Print the last traceback with the currently active exception mode.
3572 """Print the last traceback with the currently active exception mode.
3573
3573
3574 See %xmode for changing exception reporting modes."""
3574 See %xmode for changing exception reporting modes."""
3575 self.shell.showtraceback()
3575 self.shell.showtraceback()
3576
3576
3577 @skip_doctest
3577 @skip_doctest
3578 def magic_precision(self, s=''):
3578 def magic_precision(self, s=''):
3579 """Set floating point precision for pretty printing.
3579 """Set floating point precision for pretty printing.
3580
3580
3581 Can set either integer precision or a format string.
3581 Can set either integer precision or a format string.
3582
3582
3583 If numpy has been imported and precision is an int,
3583 If numpy has been imported and precision is an int,
3584 numpy display precision will also be set, via ``numpy.set_printoptions``.
3584 numpy display precision will also be set, via ``numpy.set_printoptions``.
3585
3585
3586 If no argument is given, defaults will be restored.
3586 If no argument is given, defaults will be restored.
3587
3587
3588 Examples
3588 Examples
3589 --------
3589 --------
3590 ::
3590 ::
3591
3591
3592 In [1]: from math import pi
3592 In [1]: from math import pi
3593
3593
3594 In [2]: %precision 3
3594 In [2]: %precision 3
3595 Out[2]: u'%.3f'
3595 Out[2]: u'%.3f'
3596
3596
3597 In [3]: pi
3597 In [3]: pi
3598 Out[3]: 3.142
3598 Out[3]: 3.142
3599
3599
3600 In [4]: %precision %i
3600 In [4]: %precision %i
3601 Out[4]: u'%i'
3601 Out[4]: u'%i'
3602
3602
3603 In [5]: pi
3603 In [5]: pi
3604 Out[5]: 3
3604 Out[5]: 3
3605
3605
3606 In [6]: %precision %e
3606 In [6]: %precision %e
3607 Out[6]: u'%e'
3607 Out[6]: u'%e'
3608
3608
3609 In [7]: pi**10
3609 In [7]: pi**10
3610 Out[7]: 9.364805e+04
3610 Out[7]: 9.364805e+04
3611
3611
3612 In [8]: %precision
3612 In [8]: %precision
3613 Out[8]: u'%r'
3613 Out[8]: u'%r'
3614
3614
3615 In [9]: pi**10
3615 In [9]: pi**10
3616 Out[9]: 93648.047476082982
3616 Out[9]: 93648.047476082982
3617
3617
3618 """
3618 """
3619
3619
3620 ptformatter = self.shell.display_formatter.formatters['text/plain']
3620 ptformatter = self.shell.display_formatter.formatters['text/plain']
3621 ptformatter.float_precision = s
3621 ptformatter.float_precision = s
3622 return ptformatter.float_format
3622 return ptformatter.float_format
3623
3623
3624
3624
3625 @magic_arguments.magic_arguments()
3625 @magic_arguments.magic_arguments()
3626 @magic_arguments.argument(
3626 @magic_arguments.argument(
3627 '-e', '--export', action='store_true', default=False,
3627 '-e', '--export', action='store_true', default=False,
3628 help='Export IPython history as a notebook. The filename argument '
3628 help='Export IPython history as a notebook. The filename argument '
3629 'is used to specify the notebook name and format. For example '
3629 'is used to specify the notebook name and format. For example '
3630 'a filename of notebook.ipynb will result in a notebook name '
3630 'a filename of notebook.ipynb will result in a notebook name '
3631 'of "notebook" and a format of "xml". Likewise using a ".json" '
3631 'of "notebook" and a format of "xml". Likewise using a ".json" '
3632 'or ".py" file extension will write the notebook in the json '
3632 'or ".py" file extension will write the notebook in the json '
3633 'or py formats.'
3633 'or py formats.'
3634 )
3634 )
3635 @magic_arguments.argument(
3635 @magic_arguments.argument(
3636 '-f', '--format',
3636 '-f', '--format',
3637 help='Convert an existing IPython notebook to a new format. This option '
3637 help='Convert an existing IPython notebook to a new format. This option '
3638 'specifies the new format and can have the values: xml, json, py. '
3638 'specifies the new format and can have the values: xml, json, py. '
3639 'The target filename is chosen automatically based on the new '
3639 'The target filename is chosen automatically based on the new '
3640 'format. The filename argument gives the name of the source file.'
3640 'format. The filename argument gives the name of the source file.'
3641 )
3641 )
3642 @magic_arguments.argument(
3642 @magic_arguments.argument(
3643 'filename', type=unicode,
3643 'filename', type=unicode,
3644 help='Notebook name or filename'
3644 help='Notebook name or filename'
3645 )
3645 )
3646 def magic_notebook(self, s):
3646 def magic_notebook(self, s):
3647 """Export and convert IPython notebooks.
3647 """Export and convert IPython notebooks.
3648
3648
3649 This function can export the current IPython history to a notebook file
3649 This function can export the current IPython history to a notebook file
3650 or can convert an existing notebook file into a different format. For
3650 or can convert an existing notebook file into a different format. For
3651 example, to export the history to "foo.ipynb" do "%notebook -e foo.ipynb".
3651 example, to export the history to "foo.ipynb" do "%notebook -e foo.ipynb".
3652 To export the history to "foo.py" do "%notebook -e foo.py". To convert
3652 To export the history to "foo.py" do "%notebook -e foo.py". To convert
3653 "foo.ipynb" to "foo.json" do "%notebook -f json foo.ipynb". Possible
3653 "foo.ipynb" to "foo.json" do "%notebook -f json foo.ipynb". Possible
3654 formats include (json/ipynb, py).
3654 formats include (json/ipynb, py).
3655 """
3655 """
3656 args = magic_arguments.parse_argstring(self.magic_notebook, s)
3656 args = magic_arguments.parse_argstring(self.magic_notebook, s)
3657
3657
3658 from IPython.nbformat import current
3658 from IPython.nbformat import current
3659 args.filename = unquote_filename(args.filename)
3659 args.filename = unquote_filename(args.filename)
3660 if args.export:
3660 if args.export:
3661 fname, name, format = current.parse_filename(args.filename)
3661 fname, name, format = current.parse_filename(args.filename)
3662 cells = []
3662 cells = []
3663 hist = list(self.history_manager.get_range())
3663 hist = list(self.history_manager.get_range())
3664 for session, prompt_number, input in hist[:-1]:
3664 for session, prompt_number, input in hist[:-1]:
3665 cells.append(current.new_code_cell(prompt_number=prompt_number, input=input))
3665 cells.append(current.new_code_cell(prompt_number=prompt_number, input=input))
3666 worksheet = current.new_worksheet(cells=cells)
3666 worksheet = current.new_worksheet(cells=cells)
3667 nb = current.new_notebook(name=name,worksheets=[worksheet])
3667 nb = current.new_notebook(name=name,worksheets=[worksheet])
3668 with io.open(fname, 'w', encoding='utf-8') as f:
3668 with io.open(fname, 'w', encoding='utf-8') as f:
3669 current.write(nb, f, format);
3669 current.write(nb, f, format);
3670 elif args.format is not None:
3670 elif args.format is not None:
3671 old_fname, old_name, old_format = current.parse_filename(args.filename)
3671 old_fname, old_name, old_format = current.parse_filename(args.filename)
3672 new_format = args.format
3672 new_format = args.format
3673 if new_format == u'xml':
3673 if new_format == u'xml':
3674 raise ValueError('Notebooks cannot be written as xml.')
3674 raise ValueError('Notebooks cannot be written as xml.')
3675 elif new_format == u'ipynb' or new_format == u'json':
3675 elif new_format == u'ipynb' or new_format == u'json':
3676 new_fname = old_name + u'.ipynb'
3676 new_fname = old_name + u'.ipynb'
3677 new_format = u'json'
3677 new_format = u'json'
3678 elif new_format == u'py':
3678 elif new_format == u'py':
3679 new_fname = old_name + u'.py'
3679 new_fname = old_name + u'.py'
3680 else:
3680 else:
3681 raise ValueError('Invalid notebook format: %s' % new_format)
3681 raise ValueError('Invalid notebook format: %s' % new_format)
3682 with io.open(old_fname, 'r', encoding='utf-8') as f:
3682 with io.open(old_fname, 'r', encoding='utf-8') as f:
3683 nb = current.read(f, old_format)
3683 nb = current.read(f, old_format)
3684 with io.open(new_fname, 'w', encoding='utf-8') as f:
3684 with io.open(new_fname, 'w', encoding='utf-8') as f:
3685 current.write(nb, f, new_format)
3685 current.write(nb, f, new_format)
3686
3686
3687 def magic_config(self, s):
3687 def magic_config(self, s):
3688 """configure IPython
3688 """configure IPython
3689
3689
3690 %config Class[.trait=value]
3690 %config Class[.trait=value]
3691
3691
3692 This magic exposes most of the IPython config system. Any
3692 This magic exposes most of the IPython config system. Any
3693 Configurable class should be able to be configured with the simple
3693 Configurable class should be able to be configured with the simple
3694 line::
3694 line::
3695
3695
3696 %config Class.trait=value
3696 %config Class.trait=value
3697
3697
3698 Where `value` will be resolved in the user's namespace, if it is an
3698 Where `value` will be resolved in the user's namespace, if it is an
3699 expression or variable name.
3699 expression or variable name.
3700
3700
3701 Examples
3701 Examples
3702 --------
3702 --------
3703
3703
3704 To see what classes are available for config, pass no arguments::
3704 To see what classes are available for config, pass no arguments::
3705
3705
3706 In [1]: %config
3706 In [1]: %config
3707 Available objects for config:
3707 Available objects for config:
3708 TerminalInteractiveShell
3708 TerminalInteractiveShell
3709 HistoryManager
3709 HistoryManager
3710 PrefilterManager
3710 PrefilterManager
3711 AliasManager
3711 AliasManager
3712 IPCompleter
3712 IPCompleter
3713 PromptManager
3713 PromptManager
3714 DisplayFormatter
3714 DisplayFormatter
3715
3715
3716 To view what is configurable on a given class, just pass the class
3716 To view what is configurable on a given class, just pass the class
3717 name::
3717 name::
3718
3718
3719 In [2]: %config IPCompleter
3719 In [2]: %config IPCompleter
3720 IPCompleter options
3720 IPCompleter options
3721 -----------------
3721 -----------------
3722 IPCompleter.omit__names=<Enum>
3722 IPCompleter.omit__names=<Enum>
3723 Current: 2
3723 Current: 2
3724 Choices: (0, 1, 2)
3724 Choices: (0, 1, 2)
3725 Instruct the completer to omit private method names
3725 Instruct the completer to omit private method names
3726 Specifically, when completing on ``object.<tab>``.
3726 Specifically, when completing on ``object.<tab>``.
3727 When 2 [default]: all names that start with '_' will be excluded.
3727 When 2 [default]: all names that start with '_' will be excluded.
3728 When 1: all 'magic' names (``__foo__``) will be excluded.
3728 When 1: all 'magic' names (``__foo__``) will be excluded.
3729 When 0: nothing will be excluded.
3729 When 0: nothing will be excluded.
3730 IPCompleter.merge_completions=<CBool>
3730 IPCompleter.merge_completions=<CBool>
3731 Current: True
3731 Current: True
3732 Whether to merge completion results into a single list
3732 Whether to merge completion results into a single list
3733 If False, only the completion results from the first non-empty completer
3733 If False, only the completion results from the first non-empty completer
3734 will be returned.
3734 will be returned.
3735 IPCompleter.limit_to__all__=<CBool>
3735 IPCompleter.limit_to__all__=<CBool>
3736 Current: False
3736 Current: False
3737 Instruct the completer to use __all__ for the completion
3737 Instruct the completer to use __all__ for the completion
3738 Specifically, when completing on ``object.<tab>``.
3738 Specifically, when completing on ``object.<tab>``.
3739 When True: only those names in obj.__all__ will be included.
3739 When True: only those names in obj.__all__ will be included.
3740 When False [default]: the __all__ attribute is ignored
3740 When False [default]: the __all__ attribute is ignored
3741 IPCompleter.greedy=<CBool>
3741 IPCompleter.greedy=<CBool>
3742 Current: False
3742 Current: False
3743 Activate greedy completion
3743 Activate greedy completion
3744 This will enable completion on elements of lists, results of function calls,
3744 This will enable completion on elements of lists, results of function calls,
3745 etc., but can be unsafe because the code is actually evaluated on TAB.
3745 etc., but can be unsafe because the code is actually evaluated on TAB.
3746
3746
3747 but the real use is in setting values::
3747 but the real use is in setting values::
3748
3748
3749 In [3]: %config IPCompleter.greedy = True
3749 In [3]: %config IPCompleter.greedy = True
3750
3750
3751 and these values are read from the user_ns if they are variables::
3751 and these values are read from the user_ns if they are variables::
3752
3752
3753 In [4]: feeling_greedy=False
3753 In [4]: feeling_greedy=False
3754
3754
3755 In [5]: %config IPCompleter.greedy = feeling_greedy
3755 In [5]: %config IPCompleter.greedy = feeling_greedy
3756
3756
3757 """
3757 """
3758 from IPython.config.loader import Config
3758 from IPython.config.loader import Config
3759 # some IPython objects are Configurable, but do not yet have
3759 # some IPython objects are Configurable, but do not yet have
3760 # any configurable traits. Exclude them from the effects of
3760 # any configurable traits. Exclude them from the effects of
3761 # this magic, as their presence is just noise:
3761 # this magic, as their presence is just noise:
3762 configurables = [ c for c in self.configurables if c.__class__.class_traits(config=True) ]
3762 configurables = [ c for c in self.configurables if c.__class__.class_traits(config=True) ]
3763 classnames = [ c.__class__.__name__ for c in configurables ]
3763 classnames = [ c.__class__.__name__ for c in configurables ]
3764
3764
3765 line = s.strip()
3765 line = s.strip()
3766 if not line:
3766 if not line:
3767 # print available configurable names
3767 # print available configurable names
3768 print "Available objects for config:"
3768 print "Available objects for config:"
3769 for name in classnames:
3769 for name in classnames:
3770 print " ", name
3770 print " ", name
3771 return
3771 return
3772 elif line in classnames:
3772 elif line in classnames:
3773 # `%config TerminalInteractiveShell` will print trait info for
3773 # `%config TerminalInteractiveShell` will print trait info for
3774 # TerminalInteractiveShell
3774 # TerminalInteractiveShell
3775 c = configurables[classnames.index(line)]
3775 c = configurables[classnames.index(line)]
3776 cls = c.__class__
3776 cls = c.__class__
3777 help = cls.class_get_help(c)
3777 help = cls.class_get_help(c)
3778 # strip leading '--' from cl-args:
3778 # strip leading '--' from cl-args:
3779 help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
3779 help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
3780 print help
3780 print help
3781 return
3781 return
3782 elif '=' not in line:
3782 elif '=' not in line:
3783 raise UsageError("Invalid config statement: %r, should be Class.trait = value" % line)
3783 raise UsageError("Invalid config statement: %r, should be Class.trait = value" % line)
3784
3784
3785
3785
3786 # otherwise, assume we are setting configurables.
3786 # otherwise, assume we are setting configurables.
3787 # leave quotes on args when splitting, because we want
3787 # leave quotes on args when splitting, because we want
3788 # unquoted args to eval in user_ns
3788 # unquoted args to eval in user_ns
3789 cfg = Config()
3789 cfg = Config()
3790 exec "cfg."+line in locals(), self.user_ns
3790 exec "cfg."+line in locals(), self.user_ns
3791
3791
3792 for configurable in configurables:
3792 for configurable in configurables:
3793 try:
3793 try:
3794 configurable.update_config(cfg)
3794 configurable.update_config(cfg)
3795 except Exception as e:
3795 except Exception as e:
3796 error(e)
3796 error(e)
3797
3797
3798 # end Magic
3798 # end Magic
@@ -1,340 +1,340 b''
1 # encoding: utf-8
1 # encoding: utf-8
2 """
2 """
3 Paging capabilities for IPython.core
3 Paging capabilities for IPython.core
4
4
5 Authors:
5 Authors:
6
6
7 * Brian Granger
7 * Brian Granger
8 * Fernando Perez
8 * Fernando Perez
9
9
10 Notes
10 Notes
11 -----
11 -----
12
12
13 For now this uses ipapi, so it can't be in IPython.utils. If we can get
13 For now this uses ipapi, so it can't be in IPython.utils. If we can get
14 rid of that dependency, we could move it there.
14 rid of that dependency, we could move it there.
15 -----
15 -----
16 """
16 """
17
17
18 #-----------------------------------------------------------------------------
18 #-----------------------------------------------------------------------------
19 # Copyright (C) 2008-2011 The IPython Development Team
19 # Copyright (C) 2008-2011 The IPython Development Team
20 #
20 #
21 # Distributed under the terms of the BSD License. The full license is in
21 # Distributed under the terms of the BSD License. The full license is in
22 # the file COPYING, distributed as part of this software.
22 # the file COPYING, distributed as part of this software.
23 #-----------------------------------------------------------------------------
23 #-----------------------------------------------------------------------------
24
24
25 #-----------------------------------------------------------------------------
25 #-----------------------------------------------------------------------------
26 # Imports
26 # Imports
27 #-----------------------------------------------------------------------------
27 #-----------------------------------------------------------------------------
28
28
29 import os
29 import os
30 import re
30 import re
31 import sys
31 import sys
32 import tempfile
32 import tempfile
33
33
34 from io import UnsupportedOperation
34 from io import UnsupportedOperation
35
35
36 from IPython.core import ipapi
36 from IPython.core import ipapi
37 from IPython.core.error import TryNext
37 from IPython.core.error import TryNext
38 from IPython.utils.cursesimport import use_curses
38 from IPython.utils.cursesimport import use_curses
39 from IPython.utils.data import chop
39 from IPython.utils.data import chop
40 from IPython.utils import io
40 from IPython.utils import io
41 from IPython.utils.process import system
41 from IPython.utils.process import system
42 from IPython.utils.terminal import get_terminal_size
42 from IPython.utils.terminal import get_terminal_size
43
43
44
44
45 #-----------------------------------------------------------------------------
45 #-----------------------------------------------------------------------------
46 # Classes and functions
46 # Classes and functions
47 #-----------------------------------------------------------------------------
47 #-----------------------------------------------------------------------------
48
48
49 esc_re = re.compile(r"(\x1b[^m]+m)")
49 esc_re = re.compile(r"(\x1b[^m]+m)")
50
50
51 def page_dumb(strng, start=0, screen_lines=25):
51 def page_dumb(strng, start=0, screen_lines=25):
52 """Very dumb 'pager' in Python, for when nothing else works.
52 """Very dumb 'pager' in Python, for when nothing else works.
53
53
54 Only moves forward, same interface as page(), except for pager_cmd and
54 Only moves forward, same interface as page(), except for pager_cmd and
55 mode."""
55 mode."""
56
56
57 out_ln = strng.splitlines()[start:]
57 out_ln = strng.splitlines()[start:]
58 screens = chop(out_ln,screen_lines-1)
58 screens = chop(out_ln,screen_lines-1)
59 if len(screens) == 1:
59 if len(screens) == 1:
60 print >>io.stdout, os.linesep.join(screens[0])
60 print >>io.stdout, os.linesep.join(screens[0])
61 else:
61 else:
62 last_escape = ""
62 last_escape = ""
63 for scr in screens[0:-1]:
63 for scr in screens[0:-1]:
64 hunk = os.linesep.join(scr)
64 hunk = os.linesep.join(scr)
65 print >>io.stdout, last_escape + hunk
65 print >>io.stdout, last_escape + hunk
66 if not page_more():
66 if not page_more():
67 return
67 return
68 esc_list = esc_re.findall(hunk)
68 esc_list = esc_re.findall(hunk)
69 if len(esc_list) > 0:
69 if len(esc_list) > 0:
70 last_escape = esc_list[-1]
70 last_escape = esc_list[-1]
71 print >>io.stdout, last_escape + os.linesep.join(screens[-1])
71 print >>io.stdout, last_escape + os.linesep.join(screens[-1])
72
72
73 def _detect_screen_size(use_curses, screen_lines_def):
73 def _detect_screen_size(use_curses, screen_lines_def):
74 """Attempt to work out the number of lines on the screen.
74 """Attempt to work out the number of lines on the screen.
75
75
76 This is called by page(). It can raise an error (e.g. when run in the
76 This is called by page(). It can raise an error (e.g. when run in the
77 test suite), so it's separated out so it can easily be called in a try block.
77 test suite), so it's separated out so it can easily be called in a try block.
78 """
78 """
79 TERM = os.environ.get('TERM',None)
79 TERM = os.environ.get('TERM',None)
80 if (TERM=='xterm' or TERM=='xterm-color') and sys.platform != 'sunos5':
80 if (TERM=='xterm' or TERM=='xterm-color') and sys.platform != 'sunos5':
81 local_use_curses = use_curses
81 local_use_curses = use_curses
82 else:
82 else:
83 # curses causes problems on many terminals other than xterm, and
83 # curses causes problems on many terminals other than xterm, and
84 # some termios calls lock up on Sun OS5.
84 # some termios calls lock up on Sun OS5.
85 local_use_curses = False
85 local_use_curses = False
86 if local_use_curses:
86 if local_use_curses:
87 import termios
87 import termios
88 import curses
88 import curses
89 # There is a bug in curses, where *sometimes* it fails to properly
89 # There is a bug in curses, where *sometimes* it fails to properly
90 # initialize, and then after the endwin() call is made, the
90 # initialize, and then after the endwin() call is made, the
91 # terminal is left in an unusable state. Rather than trying to
91 # terminal is left in an unusable state. Rather than trying to
92 # check everytime for this (by requesting and comparing termios
92 # check everytime for this (by requesting and comparing termios
93 # flags each time), we just save the initial terminal state and
93 # flags each time), we just save the initial terminal state and
94 # unconditionally reset it every time. It's cheaper than making
94 # unconditionally reset it every time. It's cheaper than making
95 # the checks.
95 # the checks.
96 term_flags = termios.tcgetattr(sys.stdout)
96 term_flags = termios.tcgetattr(sys.stdout)
97
97
98 # Curses modifies the stdout buffer size by default, which messes
98 # Curses modifies the stdout buffer size by default, which messes
99 # up Python's normal stdout buffering. This would manifest itself
99 # up Python's normal stdout buffering. This would manifest itself
100 # to IPython users as delayed printing on stdout after having used
100 # to IPython users as delayed printing on stdout after having used
101 # the pager.
101 # the pager.
102 #
102 #
103 # We can prevent this by manually setting the NCURSES_NO_SETBUF
103 # We can prevent this by manually setting the NCURSES_NO_SETBUF
104 # environment variable. For more details, see:
104 # environment variable. For more details, see:
105 # http://bugs.python.org/issue10144
105 # http://bugs.python.org/issue10144
106 NCURSES_NO_SETBUF = os.environ.get('NCURSES_NO_SETBUF', None)
106 NCURSES_NO_SETBUF = os.environ.get('NCURSES_NO_SETBUF', None)
107 os.environ['NCURSES_NO_SETBUF'] = ''
107 os.environ['NCURSES_NO_SETBUF'] = ''
108
108
109 # Proceed with curses initialization
109 # Proceed with curses initialization
110 scr = curses.initscr()
110 scr = curses.initscr()
111 screen_lines_real,screen_cols = scr.getmaxyx()
111 screen_lines_real,screen_cols = scr.getmaxyx()
112 curses.endwin()
112 curses.endwin()
113
113
114 # Restore environment
114 # Restore environment
115 if NCURSES_NO_SETBUF is None:
115 if NCURSES_NO_SETBUF is None:
116 del os.environ['NCURSES_NO_SETBUF']
116 del os.environ['NCURSES_NO_SETBUF']
117 else:
117 else:
118 os.environ['NCURSES_NO_SETBUF'] = NCURSES_NO_SETBUF
118 os.environ['NCURSES_NO_SETBUF'] = NCURSES_NO_SETBUF
119
119
120 # Restore terminal state in case endwin() didn't.
120 # Restore terminal state in case endwin() didn't.
121 termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
121 termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
122 # Now we have what we needed: the screen size in rows/columns
122 # Now we have what we needed: the screen size in rows/columns
123 return screen_lines_real
123 return screen_lines_real
124 #print '***Screen size:',screen_lines_real,'lines x',\
124 #print '***Screen size:',screen_lines_real,'lines x',\
125 #screen_cols,'columns.' # dbg
125 #screen_cols,'columns.' # dbg
126 else:
126 else:
127 return screen_lines_def
127 return screen_lines_def
128
128
129 def page(strng, start=0, screen_lines=0, pager_cmd=None):
129 def page(strng, start=0, screen_lines=0, pager_cmd=None):
130 """Print a string, piping through a pager after a certain length.
130 """Print a string, piping through a pager after a certain length.
131
131
132 The screen_lines parameter specifies the number of *usable* lines of your
132 The screen_lines parameter specifies the number of *usable* lines of your
133 terminal screen (total lines minus lines you need to reserve to show other
133 terminal screen (total lines minus lines you need to reserve to show other
134 information).
134 information).
135
135
136 If you set screen_lines to a number <=0, page() will try to auto-determine
136 If you set screen_lines to a number <=0, page() will try to auto-determine
137 your screen size and will only use up to (screen_size+screen_lines) for
137 your screen size and will only use up to (screen_size+screen_lines) for
138 printing, paging after that. That is, if you want auto-detection but need
138 printing, paging after that. That is, if you want auto-detection but need
139 to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
139 to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
140 auto-detection without any lines reserved simply use screen_lines = 0.
140 auto-detection without any lines reserved simply use screen_lines = 0.
141
141
142 If a string won't fit in the allowed lines, it is sent through the
142 If a string won't fit in the allowed lines, it is sent through the
143 specified pager command. If none given, look for PAGER in the environment,
143 specified pager command. If none given, look for PAGER in the environment,
144 and ultimately default to less.
144 and ultimately default to less.
145
145
146 If no system pager works, the string is sent through a 'dumb pager'
146 If no system pager works, the string is sent through a 'dumb pager'
147 written in python, very simplistic.
147 written in python, very simplistic.
148 """
148 """
149
149
150 # Some routines may auto-compute start offsets incorrectly and pass a
150 # Some routines may auto-compute start offsets incorrectly and pass a
151 # negative value. Offset to 0 for robustness.
151 # negative value. Offset to 0 for robustness.
152 start = max(0, start)
152 start = max(0, start)
153
153
154 # first, try the hook
154 # first, try the hook
155 ip = ipapi.get()
155 ip = ipapi.get()
156 if ip:
156 if ip:
157 try:
157 try:
158 ip.hooks.show_in_pager(strng)
158 ip.hooks.show_in_pager(strng)
159 return
159 return
160 except TryNext:
160 except TryNext:
161 pass
161 pass
162
162
163 # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
163 # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
164 TERM = os.environ.get('TERM','dumb')
164 TERM = os.environ.get('TERM','dumb')
165 if TERM in ['dumb','emacs'] and os.name != 'nt':
165 if TERM in ['dumb','emacs'] and os.name != 'nt':
166 print strng
166 print strng
167 return
167 return
168 # chop off the topmost part of the string we don't want to see
168 # chop off the topmost part of the string we don't want to see
169 str_lines = strng.splitlines()[start:]
169 str_lines = strng.splitlines()[start:]
170 str_toprint = os.linesep.join(str_lines)
170 str_toprint = os.linesep.join(str_lines)
171 num_newlines = len(str_lines)
171 num_newlines = len(str_lines)
172 len_str = len(str_toprint)
172 len_str = len(str_toprint)
173
173
174 # Dumb heuristics to guesstimate number of on-screen lines the string
174 # Dumb heuristics to guesstimate number of on-screen lines the string
175 # takes. Very basic, but good enough for docstrings in reasonable
175 # takes. Very basic, but good enough for docstrings in reasonable
176 # terminals. If someone later feels like refining it, it's not hard.
176 # terminals. If someone later feels like refining it, it's not hard.
177 numlines = max(num_newlines,int(len_str/80)+1)
177 numlines = max(num_newlines,int(len_str/80)+1)
178
178
179 screen_lines_def = get_terminal_size()[1]
179 screen_lines_def = get_terminal_size()[1]
180
180
181 # auto-determine screen size
181 # auto-determine screen size
182 if screen_lines <= 0:
182 if screen_lines <= 0:
183 try:
183 try:
184 screen_lines += _detect_screen_size(use_curses, screen_lines_def)
184 screen_lines += _detect_screen_size(use_curses, screen_lines_def)
185 except (TypeError, UnsupportedOperation):
185 except (TypeError, UnsupportedOperation):
186 print >>io.stdout, str_toprint
186 print >>io.stdout, str_toprint
187 return
187 return
188
188
189 #print 'numlines',numlines,'screenlines',screen_lines # dbg
189 #print 'numlines',numlines,'screenlines',screen_lines # dbg
190 if numlines <= screen_lines :
190 if numlines <= screen_lines :
191 #print '*** normal print' # dbg
191 #print '*** normal print' # dbg
192 print >>io.stdout, str_toprint
192 print >>io.stdout, str_toprint
193 else:
193 else:
194 # Try to open pager and default to internal one if that fails.
194 # Try to open pager and default to internal one if that fails.
195 # All failure modes are tagged as 'retval=1', to match the return
195 # All failure modes are tagged as 'retval=1', to match the return
196 # value of a failed system command. If any intermediate attempt
196 # value of a failed system command. If any intermediate attempt
197 # sets retval to 1, at the end we resort to our own page_dumb() pager.
197 # sets retval to 1, at the end we resort to our own page_dumb() pager.
198 pager_cmd = get_pager_cmd(pager_cmd)
198 pager_cmd = get_pager_cmd(pager_cmd)
199 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
199 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
200 if os.name == 'nt':
200 if os.name == 'nt':
201 if pager_cmd.startswith('type'):
201 if pager_cmd.startswith('type'):
202 # The default WinXP 'type' command is failing on complex strings.
202 # The default WinXP 'type' command is failing on complex strings.
203 retval = 1
203 retval = 1
204 else:
204 else:
205 tmpname = tempfile.mktemp('.txt')
205 tmpname = tempfile.mktemp('.txt')
206 tmpfile = file(tmpname,'wt')
206 tmpfile = open(tmpname,'wt')
207 tmpfile.write(strng)
207 tmpfile.write(strng)
208 tmpfile.close()
208 tmpfile.close()
209 cmd = "%s < %s" % (pager_cmd,tmpname)
209 cmd = "%s < %s" % (pager_cmd,tmpname)
210 if os.system(cmd):
210 if os.system(cmd):
211 retval = 1
211 retval = 1
212 else:
212 else:
213 retval = None
213 retval = None
214 os.remove(tmpname)
214 os.remove(tmpname)
215 else:
215 else:
216 try:
216 try:
217 retval = None
217 retval = None
218 # if I use popen4, things hang. No idea why.
218 # if I use popen4, things hang. No idea why.
219 #pager,shell_out = os.popen4(pager_cmd)
219 #pager,shell_out = os.popen4(pager_cmd)
220 pager = os.popen(pager_cmd,'w')
220 pager = os.popen(pager_cmd,'w')
221 pager.write(strng)
221 pager.write(strng)
222 pager.close()
222 pager.close()
223 retval = pager.close() # success returns None
223 retval = pager.close() # success returns None
224 except IOError,msg: # broken pipe when user quits
224 except IOError,msg: # broken pipe when user quits
225 if msg.args == (32,'Broken pipe'):
225 if msg.args == (32,'Broken pipe'):
226 retval = None
226 retval = None
227 else:
227 else:
228 retval = 1
228 retval = 1
229 except OSError:
229 except OSError:
230 # Other strange problems, sometimes seen in Win2k/cygwin
230 # Other strange problems, sometimes seen in Win2k/cygwin
231 retval = 1
231 retval = 1
232 if retval is not None:
232 if retval is not None:
233 page_dumb(strng,screen_lines=screen_lines)
233 page_dumb(strng,screen_lines=screen_lines)
234
234
235
235
236 def page_file(fname, start=0, pager_cmd=None):
236 def page_file(fname, start=0, pager_cmd=None):
237 """Page a file, using an optional pager command and starting line.
237 """Page a file, using an optional pager command and starting line.
238 """
238 """
239
239
240 pager_cmd = get_pager_cmd(pager_cmd)
240 pager_cmd = get_pager_cmd(pager_cmd)
241 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
241 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
242
242
243 try:
243 try:
244 if os.environ['TERM'] in ['emacs','dumb']:
244 if os.environ['TERM'] in ['emacs','dumb']:
245 raise EnvironmentError
245 raise EnvironmentError
246 system(pager_cmd + ' ' + fname)
246 system(pager_cmd + ' ' + fname)
247 except:
247 except:
248 try:
248 try:
249 if start > 0:
249 if start > 0:
250 start -= 1
250 start -= 1
251 page(open(fname).read(),start)
251 page(open(fname).read(),start)
252 except:
252 except:
253 print 'Unable to show file',`fname`
253 print 'Unable to show file',`fname`
254
254
255
255
256 def get_pager_cmd(pager_cmd=None):
256 def get_pager_cmd(pager_cmd=None):
257 """Return a pager command.
257 """Return a pager command.
258
258
259 Makes some attempts at finding an OS-correct one.
259 Makes some attempts at finding an OS-correct one.
260 """
260 """
261 if os.name == 'posix':
261 if os.name == 'posix':
262 default_pager_cmd = 'less -r' # -r for color control sequences
262 default_pager_cmd = 'less -r' # -r for color control sequences
263 elif os.name in ['nt','dos']:
263 elif os.name in ['nt','dos']:
264 default_pager_cmd = 'type'
264 default_pager_cmd = 'type'
265
265
266 if pager_cmd is None:
266 if pager_cmd is None:
267 try:
267 try:
268 pager_cmd = os.environ['PAGER']
268 pager_cmd = os.environ['PAGER']
269 except:
269 except:
270 pager_cmd = default_pager_cmd
270 pager_cmd = default_pager_cmd
271 return pager_cmd
271 return pager_cmd
272
272
273
273
274 def get_pager_start(pager, start):
274 def get_pager_start(pager, start):
275 """Return the string for paging files with an offset.
275 """Return the string for paging files with an offset.
276
276
277 This is the '+N' argument which less and more (under Unix) accept.
277 This is the '+N' argument which less and more (under Unix) accept.
278 """
278 """
279
279
280 if pager in ['less','more']:
280 if pager in ['less','more']:
281 if start:
281 if start:
282 start_string = '+' + str(start)
282 start_string = '+' + str(start)
283 else:
283 else:
284 start_string = ''
284 start_string = ''
285 else:
285 else:
286 start_string = ''
286 start_string = ''
287 return start_string
287 return start_string
288
288
289
289
290 # (X)emacs on win32 doesn't like to be bypassed with msvcrt.getch()
290 # (X)emacs on win32 doesn't like to be bypassed with msvcrt.getch()
291 if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
291 if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
292 import msvcrt
292 import msvcrt
293 def page_more():
293 def page_more():
294 """ Smart pausing between pages
294 """ Smart pausing between pages
295
295
296 @return: True if need print more lines, False if quit
296 @return: True if need print more lines, False if quit
297 """
297 """
298 io.stdout.write('---Return to continue, q to quit--- ')
298 io.stdout.write('---Return to continue, q to quit--- ')
299 ans = msvcrt.getch()
299 ans = msvcrt.getch()
300 if ans in ("q", "Q"):
300 if ans in ("q", "Q"):
301 result = False
301 result = False
302 else:
302 else:
303 result = True
303 result = True
304 io.stdout.write("\b"*37 + " "*37 + "\b"*37)
304 io.stdout.write("\b"*37 + " "*37 + "\b"*37)
305 return result
305 return result
306 else:
306 else:
307 def page_more():
307 def page_more():
308 ans = raw_input('---Return to continue, q to quit--- ')
308 ans = raw_input('---Return to continue, q to quit--- ')
309 if ans.lower().startswith('q'):
309 if ans.lower().startswith('q'):
310 return False
310 return False
311 else:
311 else:
312 return True
312 return True
313
313
314
314
315 def snip_print(str,width = 75,print_full = 0,header = ''):
315 def snip_print(str,width = 75,print_full = 0,header = ''):
316 """Print a string snipping the midsection to fit in width.
316 """Print a string snipping the midsection to fit in width.
317
317
318 print_full: mode control:
318 print_full: mode control:
319 - 0: only snip long strings
319 - 0: only snip long strings
320 - 1: send to page() directly.
320 - 1: send to page() directly.
321 - 2: snip long strings and ask for full length viewing with page()
321 - 2: snip long strings and ask for full length viewing with page()
322 Return 1 if snipping was necessary, 0 otherwise."""
322 Return 1 if snipping was necessary, 0 otherwise."""
323
323
324 if print_full == 1:
324 if print_full == 1:
325 page(header+str)
325 page(header+str)
326 return 0
326 return 0
327
327
328 print header,
328 print header,
329 if len(str) < width:
329 if len(str) < width:
330 print str
330 print str
331 snip = 0
331 snip = 0
332 else:
332 else:
333 whalf = int((width -5)/2)
333 whalf = int((width -5)/2)
334 print str[:whalf] + ' <...> ' + str[-whalf:]
334 print str[:whalf] + ' <...> ' + str[-whalf:]
335 snip = 1
335 snip = 1
336 if snip and print_full == 2:
336 if snip and print_full == 2:
337 if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
337 if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
338 page(str)
338 page(str)
339 return snip
339 return snip
340
340
@@ -1,947 +1,947 b''
1 """ path.py - An object representing a path to a file or directory.
1 """ path.py - An object representing a path to a file or directory.
2
2
3 Example:
3 Example:
4
4
5 from IPython.external.path import path
5 from IPython.external.path import path
6 d = path('/home/guido/bin')
6 d = path('/home/guido/bin')
7 for f in d.files('*.py'):
7 for f in d.files('*.py'):
8 f.chmod(0755)
8 f.chmod(0755)
9
9
10 This module requires Python 2.5 or later.
10 This module requires Python 2.5 or later.
11
11
12
12
13 URL: http://pypi.python.org/pypi/path.py
13 URL: http://pypi.python.org/pypi/path.py
14 Author: Jason Orendorff <jason.orendorff\x40gmail\x2ecom> (and others - see the url!)
14 Author: Jason Orendorff <jason.orendorff\x40gmail\x2ecom> (and others - see the url!)
15 Date: 9 Mar 2007
15 Date: 9 Mar 2007
16 """
16 """
17
17
18
18
19 # TODO
19 # TODO
20 # - Tree-walking functions don't avoid symlink loops. Matt Harrison
20 # - Tree-walking functions don't avoid symlink loops. Matt Harrison
21 # sent me a patch for this.
21 # sent me a patch for this.
22 # - Bug in write_text(). It doesn't support Universal newline mode.
22 # - Bug in write_text(). It doesn't support Universal newline mode.
23 # - Better error message in listdir() when self isn't a
23 # - Better error message in listdir() when self isn't a
24 # directory. (On Windows, the error message really sucks.)
24 # directory. (On Windows, the error message really sucks.)
25 # - Make sure everything has a good docstring.
25 # - Make sure everything has a good docstring.
26 # - Add methods for regex find and replace.
26 # - Add methods for regex find and replace.
27 # - guess_content_type() method?
27 # - guess_content_type() method?
28 # - Perhaps support arguments to touch().
28 # - Perhaps support arguments to touch().
29
29
30 from __future__ import generators
30 from __future__ import generators
31
31
32 import sys, warnings, os, fnmatch, glob, shutil, codecs
32 import sys, warnings, os, fnmatch, glob, shutil, codecs
33 from hashlib import md5
33 from hashlib import md5
34
34
35 __version__ = '2.2'
35 __version__ = '2.2'
36 __all__ = ['path']
36 __all__ = ['path']
37
37
38 # Platform-specific support for path.owner
38 # Platform-specific support for path.owner
39 if os.name == 'nt':
39 if os.name == 'nt':
40 try:
40 try:
41 import win32security
41 import win32security
42 except ImportError:
42 except ImportError:
43 win32security = None
43 win32security = None
44 else:
44 else:
45 try:
45 try:
46 import pwd
46 import pwd
47 except ImportError:
47 except ImportError:
48 pwd = None
48 pwd = None
49
49
50
50
51 class TreeWalkWarning(Warning):
51 class TreeWalkWarning(Warning):
52 pass
52 pass
53
53
54 class path(unicode):
54 class path(unicode):
55 """ Represents a filesystem path.
55 """ Represents a filesystem path.
56
56
57 For documentation on individual methods, consult their
57 For documentation on individual methods, consult their
58 counterparts in os.path.
58 counterparts in os.path.
59 """
59 """
60
60
61 # --- Special Python methods.
61 # --- Special Python methods.
62
62
63 def __repr__(self):
63 def __repr__(self):
64 return 'path(%s)' % unicode.__repr__(self)
64 return 'path(%s)' % unicode.__repr__(self)
65
65
66 # Adding a path and a string yields a path.
66 # Adding a path and a string yields a path.
67 def __add__(self, more):
67 def __add__(self, more):
68 try:
68 try:
69 resultStr = unicode.__add__(self, more)
69 resultStr = unicode.__add__(self, more)
70 except TypeError: #Python bug
70 except TypeError: #Python bug
71 resultStr = NotImplemented
71 resultStr = NotImplemented
72 if resultStr is NotImplemented:
72 if resultStr is NotImplemented:
73 return resultStr
73 return resultStr
74 return self.__class__(resultStr)
74 return self.__class__(resultStr)
75
75
76 def __radd__(self, other):
76 def __radd__(self, other):
77 if isinstance(other, basestring):
77 if isinstance(other, basestring):
78 return self.__class__(other.__add__(self))
78 return self.__class__(other.__add__(self))
79 else:
79 else:
80 return NotImplemented
80 return NotImplemented
81
81
82 # The / operator joins paths.
82 # The / operator joins paths.
83 def __div__(self, rel):
83 def __div__(self, rel):
84 """ fp.__div__(rel) == fp / rel == fp.joinpath(rel)
84 """ fp.__div__(rel) == fp / rel == fp.joinpath(rel)
85
85
86 Join two path components, adding a separator character if
86 Join two path components, adding a separator character if
87 needed.
87 needed.
88 """
88 """
89 return self.__class__(os.path.join(self, rel))
89 return self.__class__(os.path.join(self, rel))
90
90
91 # Make the / operator work even when true division is enabled.
91 # Make the / operator work even when true division is enabled.
92 __truediv__ = __div__
92 __truediv__ = __div__
93
93
94 def getcwd(cls):
94 def getcwd(cls):
95 """ Return the current working directory as a path object. """
95 """ Return the current working directory as a path object. """
96 return cls(os.getcwdu())
96 return cls(os.getcwdu())
97 getcwd = classmethod(getcwd)
97 getcwd = classmethod(getcwd)
98
98
99
99
100 # --- Operations on path strings.
100 # --- Operations on path strings.
101
101
102 def isabs(s): return os.path.isabs(s)
102 def isabs(s): return os.path.isabs(s)
103 def abspath(self): return self.__class__(os.path.abspath(self))
103 def abspath(self): return self.__class__(os.path.abspath(self))
104 def normcase(self): return self.__class__(os.path.normcase(self))
104 def normcase(self): return self.__class__(os.path.normcase(self))
105 def normpath(self): return self.__class__(os.path.normpath(self))
105 def normpath(self): return self.__class__(os.path.normpath(self))
106 def realpath(self): return self.__class__(os.path.realpath(self))
106 def realpath(self): return self.__class__(os.path.realpath(self))
107 def expanduser(self): return self.__class__(os.path.expanduser(self))
107 def expanduser(self): return self.__class__(os.path.expanduser(self))
108 def expandvars(self): return self.__class__(os.path.expandvars(self))
108 def expandvars(self): return self.__class__(os.path.expandvars(self))
109 def dirname(self): return self.__class__(os.path.dirname(self))
109 def dirname(self): return self.__class__(os.path.dirname(self))
110 def basename(s): return os.path.basename(s)
110 def basename(s): return os.path.basename(s)
111
111
112 def expand(self):
112 def expand(self):
113 """ Clean up a filename by calling expandvars(),
113 """ Clean up a filename by calling expandvars(),
114 expanduser(), and normpath() on it.
114 expanduser(), and normpath() on it.
115
115
116 This is commonly everything needed to clean up a filename
116 This is commonly everything needed to clean up a filename
117 read from a configuration file, for example.
117 read from a configuration file, for example.
118 """
118 """
119 return self.expandvars().expanduser().normpath()
119 return self.expandvars().expanduser().normpath()
120
120
121 def _get_namebase(self):
121 def _get_namebase(self):
122 base, ext = os.path.splitext(self.name)
122 base, ext = os.path.splitext(self.name)
123 return base
123 return base
124
124
125 def _get_ext(self):
125 def _get_ext(self):
126 f, ext = os.path.splitext(unicode(self))
126 f, ext = os.path.splitext(unicode(self))
127 return ext
127 return ext
128
128
129 def _get_drive(self):
129 def _get_drive(self):
130 drive, r = os.path.splitdrive(self)
130 drive, r = os.path.splitdrive(self)
131 return self.__class__(drive)
131 return self.__class__(drive)
132
132
133 parent = property(
133 parent = property(
134 dirname, None, None,
134 dirname, None, None,
135 """ This path's parent directory, as a new path object.
135 """ This path's parent directory, as a new path object.
136
136
137 For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')
137 For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')
138 """)
138 """)
139
139
140 name = property(
140 name = property(
141 basename, None, None,
141 basename, None, None,
142 """ The name of this file or directory without the full path.
142 """ The name of this file or directory without the full path.
143
143
144 For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'
144 For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'
145 """)
145 """)
146
146
147 namebase = property(
147 namebase = property(
148 _get_namebase, None, None,
148 _get_namebase, None, None,
149 """ The same as path.name, but with one file extension stripped off.
149 """ The same as path.name, but with one file extension stripped off.
150
150
151 For example, path('/home/guido/python.tar.gz').name == 'python.tar.gz',
151 For example, path('/home/guido/python.tar.gz').name == 'python.tar.gz',
152 but path('/home/guido/python.tar.gz').namebase == 'python.tar'
152 but path('/home/guido/python.tar.gz').namebase == 'python.tar'
153 """)
153 """)
154
154
155 ext = property(
155 ext = property(
156 _get_ext, None, None,
156 _get_ext, None, None,
157 """ The file extension, for example '.py'. """)
157 """ The file extension, for example '.py'. """)
158
158
159 drive = property(
159 drive = property(
160 _get_drive, None, None,
160 _get_drive, None, None,
161 """ The drive specifier, for example 'C:'.
161 """ The drive specifier, for example 'C:'.
162 This is always empty on systems that don't use drive specifiers.
162 This is always empty on systems that don't use drive specifiers.
163 """)
163 """)
164
164
165 def splitpath(self):
165 def splitpath(self):
166 """ p.splitpath() -> Return (p.parent, p.name). """
166 """ p.splitpath() -> Return (p.parent, p.name). """
167 parent, child = os.path.split(self)
167 parent, child = os.path.split(self)
168 return self.__class__(parent), child
168 return self.__class__(parent), child
169
169
170 def splitdrive(self):
170 def splitdrive(self):
171 """ p.splitdrive() -> Return (p.drive, <the rest of p>).
171 """ p.splitdrive() -> Return (p.drive, <the rest of p>).
172
172
173 Split the drive specifier from this path. If there is
173 Split the drive specifier from this path. If there is
174 no drive specifier, p.drive is empty, so the return value
174 no drive specifier, p.drive is empty, so the return value
175 is simply (path(''), p). This is always the case on Unix.
175 is simply (path(''), p). This is always the case on Unix.
176 """
176 """
177 drive, rel = os.path.splitdrive(self)
177 drive, rel = os.path.splitdrive(self)
178 return self.__class__(drive), rel
178 return self.__class__(drive), rel
179
179
180 def splitext(self):
180 def splitext(self):
181 """ p.splitext() -> Return (p.stripext(), p.ext).
181 """ p.splitext() -> Return (p.stripext(), p.ext).
182
182
183 Split the filename extension from this path and return
183 Split the filename extension from this path and return
184 the two parts. Either part may be empty.
184 the two parts. Either part may be empty.
185
185
186 The extension is everything from '.' to the end of the
186 The extension is everything from '.' to the end of the
187 last path segment. This has the property that if
187 last path segment. This has the property that if
188 (a, b) == p.splitext(), then a + b == p.
188 (a, b) == p.splitext(), then a + b == p.
189 """
189 """
190 filename, ext = os.path.splitext(self)
190 filename, ext = os.path.splitext(self)
191 return self.__class__(filename), ext
191 return self.__class__(filename), ext
192
192
193 def stripext(self):
193 def stripext(self):
194 """ p.stripext() -> Remove one file extension from the path.
194 """ p.stripext() -> Remove one file extension from the path.
195
195
196 For example, path('/home/guido/python.tar.gz').stripext()
196 For example, path('/home/guido/python.tar.gz').stripext()
197 returns path('/home/guido/python.tar').
197 returns path('/home/guido/python.tar').
198 """
198 """
199 return self.splitext()[0]
199 return self.splitext()[0]
200
200
201 if hasattr(os.path, 'splitunc'):
201 if hasattr(os.path, 'splitunc'):
202 def splitunc(self):
202 def splitunc(self):
203 unc, rest = os.path.splitunc(self)
203 unc, rest = os.path.splitunc(self)
204 return self.__class__(unc), rest
204 return self.__class__(unc), rest
205
205
206 def _get_uncshare(self):
206 def _get_uncshare(self):
207 unc, r = os.path.splitunc(self)
207 unc, r = os.path.splitunc(self)
208 return self.__class__(unc)
208 return self.__class__(unc)
209
209
210 uncshare = property(
210 uncshare = property(
211 _get_uncshare, None, None,
211 _get_uncshare, None, None,
212 """ The UNC mount point for this path.
212 """ The UNC mount point for this path.
213 This is empty for paths on local drives. """)
213 This is empty for paths on local drives. """)
214
214
215 def joinpath(self, *args):
215 def joinpath(self, *args):
216 """ Join two or more path components, adding a separator
216 """ Join two or more path components, adding a separator
217 character (os.sep) if needed. Returns a new path
217 character (os.sep) if needed. Returns a new path
218 object.
218 object.
219 """
219 """
220 return self.__class__(os.path.join(self, *args))
220 return self.__class__(os.path.join(self, *args))
221
221
222 def splitall(self):
222 def splitall(self):
223 r""" Return a list of the path components in this path.
223 r""" Return a list of the path components in this path.
224
224
225 The first item in the list will be a path. Its value will be
225 The first item in the list will be a path. Its value will be
226 either os.curdir, os.pardir, empty, or the root directory of
226 either os.curdir, os.pardir, empty, or the root directory of
227 this path (for example, '/' or 'C:\\'). The other items in
227 this path (for example, '/' or 'C:\\'). The other items in
228 the list will be strings.
228 the list will be strings.
229
229
230 path.path.joinpath(*result) will yield the original path.
230 path.path.joinpath(*result) will yield the original path.
231 """
231 """
232 parts = []
232 parts = []
233 loc = self
233 loc = self
234 while loc != os.curdir and loc != os.pardir:
234 while loc != os.curdir and loc != os.pardir:
235 prev = loc
235 prev = loc
236 loc, child = prev.splitpath()
236 loc, child = prev.splitpath()
237 if loc == prev:
237 if loc == prev:
238 break
238 break
239 parts.append(child)
239 parts.append(child)
240 parts.append(loc)
240 parts.append(loc)
241 parts.reverse()
241 parts.reverse()
242 return parts
242 return parts
243
243
244 def relpath(self):
244 def relpath(self):
245 """ Return this path as a relative path,
245 """ Return this path as a relative path,
246 based from the current working directory.
246 based from the current working directory.
247 """
247 """
248 cwd = self.__class__(os.getcwdu())
248 cwd = self.__class__(os.getcwdu())
249 return cwd.relpathto(self)
249 return cwd.relpathto(self)
250
250
251 def relpathto(self, dest):
251 def relpathto(self, dest):
252 """ Return a relative path from self to dest.
252 """ Return a relative path from self to dest.
253
253
254 If there is no relative path from self to dest, for example if
254 If there is no relative path from self to dest, for example if
255 they reside on different drives in Windows, then this returns
255 they reside on different drives in Windows, then this returns
256 dest.abspath().
256 dest.abspath().
257 """
257 """
258 origin = self.abspath()
258 origin = self.abspath()
259 dest = self.__class__(dest).abspath()
259 dest = self.__class__(dest).abspath()
260
260
261 orig_list = origin.normcase().splitall()
261 orig_list = origin.normcase().splitall()
262 # Don't normcase dest! We want to preserve the case.
262 # Don't normcase dest! We want to preserve the case.
263 dest_list = dest.splitall()
263 dest_list = dest.splitall()
264
264
265 if orig_list[0] != os.path.normcase(dest_list[0]):
265 if orig_list[0] != os.path.normcase(dest_list[0]):
266 # Can't get here from there.
266 # Can't get here from there.
267 return dest
267 return dest
268
268
269 # Find the location where the two paths start to differ.
269 # Find the location where the two paths start to differ.
270 i = 0
270 i = 0
271 for start_seg, dest_seg in zip(orig_list, dest_list):
271 for start_seg, dest_seg in zip(orig_list, dest_list):
272 if start_seg != os.path.normcase(dest_seg):
272 if start_seg != os.path.normcase(dest_seg):
273 break
273 break
274 i += 1
274 i += 1
275
275
276 # Now i is the point where the two paths diverge.
276 # Now i is the point where the two paths diverge.
277 # Need a certain number of "os.pardir"s to work up
277 # Need a certain number of "os.pardir"s to work up
278 # from the origin to the point of divergence.
278 # from the origin to the point of divergence.
279 segments = [os.pardir] * (len(orig_list) - i)
279 segments = [os.pardir] * (len(orig_list) - i)
280 # Need to add the diverging part of dest_list.
280 # Need to add the diverging part of dest_list.
281 segments += dest_list[i:]
281 segments += dest_list[i:]
282 if len(segments) == 0:
282 if len(segments) == 0:
283 # If they happen to be identical, use os.curdir.
283 # If they happen to be identical, use os.curdir.
284 relpath = os.curdir
284 relpath = os.curdir
285 else:
285 else:
286 relpath = os.path.join(*segments)
286 relpath = os.path.join(*segments)
287 return self.__class__(relpath)
287 return self.__class__(relpath)
288
288
289 # --- Listing, searching, walking, and matching
289 # --- Listing, searching, walking, and matching
290
290
291 def listdir(self, pattern=None):
291 def listdir(self, pattern=None):
292 """ D.listdir() -> List of items in this directory.
292 """ D.listdir() -> List of items in this directory.
293
293
294 Use D.files() or D.dirs() instead if you want a listing
294 Use D.files() or D.dirs() instead if you want a listing
295 of just files or just subdirectories.
295 of just files or just subdirectories.
296
296
297 The elements of the list are path objects.
297 The elements of the list are path objects.
298
298
299 With the optional 'pattern' argument, this only lists
299 With the optional 'pattern' argument, this only lists
300 items whose names match the given pattern.
300 items whose names match the given pattern.
301 """
301 """
302 names = os.listdir(self)
302 names = os.listdir(self)
303 if pattern is not None:
303 if pattern is not None:
304 names = fnmatch.filter(names, pattern)
304 names = fnmatch.filter(names, pattern)
305 return [self / child for child in names]
305 return [self / child for child in names]
306
306
307 def dirs(self, pattern=None):
307 def dirs(self, pattern=None):
308 """ D.dirs() -> List of this directory's subdirectories.
308 """ D.dirs() -> List of this directory's subdirectories.
309
309
310 The elements of the list are path objects.
310 The elements of the list are path objects.
311 This does not walk recursively into subdirectories
311 This does not walk recursively into subdirectories
312 (but see path.walkdirs).
312 (but see path.walkdirs).
313
313
314 With the optional 'pattern' argument, this only lists
314 With the optional 'pattern' argument, this only lists
315 directories whose names match the given pattern. For
315 directories whose names match the given pattern. For
316 example, d.dirs('build-*').
316 example, d.dirs('build-*').
317 """
317 """
318 return [p for p in self.listdir(pattern) if p.isdir()]
318 return [p for p in self.listdir(pattern) if p.isdir()]
319
319
320 def files(self, pattern=None):
320 def files(self, pattern=None):
321 """ D.files() -> List of the files in this directory.
321 """ D.files() -> List of the files in this directory.
322
322
323 The elements of the list are path objects.
323 The elements of the list are path objects.
324 This does not walk into subdirectories (see path.walkfiles).
324 This does not walk into subdirectories (see path.walkfiles).
325
325
326 With the optional 'pattern' argument, this only lists files
326 With the optional 'pattern' argument, this only lists files
327 whose names match the given pattern. For example,
327 whose names match the given pattern. For example,
328 d.files('*.pyc').
328 d.files('*.pyc').
329 """
329 """
330
330
331 return [p for p in self.listdir(pattern) if p.isfile()]
331 return [p for p in self.listdir(pattern) if p.isfile()]
332
332
333 def walk(self, pattern=None, errors='strict'):
333 def walk(self, pattern=None, errors='strict'):
334 """ D.walk() -> iterator over files and subdirs, recursively.
334 """ D.walk() -> iterator over files and subdirs, recursively.
335
335
336 The iterator yields path objects naming each child item of
336 The iterator yields path objects naming each child item of
337 this directory and its descendants. This requires that
337 this directory and its descendants. This requires that
338 D.isdir().
338 D.isdir().
339
339
340 This performs a depth-first traversal of the directory tree.
340 This performs a depth-first traversal of the directory tree.
341 Each directory is returned just before all its children.
341 Each directory is returned just before all its children.
342
342
343 The errors= keyword argument controls behavior when an
343 The errors= keyword argument controls behavior when an
344 error occurs. The default is 'strict', which causes an
344 error occurs. The default is 'strict', which causes an
345 exception. The other allowed values are 'warn', which
345 exception. The other allowed values are 'warn', which
346 reports the error via warnings.warn(), and 'ignore'.
346 reports the error via warnings.warn(), and 'ignore'.
347 """
347 """
348 if errors not in ('strict', 'warn', 'ignore'):
348 if errors not in ('strict', 'warn', 'ignore'):
349 raise ValueError("invalid errors parameter")
349 raise ValueError("invalid errors parameter")
350
350
351 try:
351 try:
352 childList = self.listdir()
352 childList = self.listdir()
353 except Exception:
353 except Exception:
354 if errors == 'ignore':
354 if errors == 'ignore':
355 return
355 return
356 elif errors == 'warn':
356 elif errors == 'warn':
357 warnings.warn(
357 warnings.warn(
358 "Unable to list directory '%s': %s"
358 "Unable to list directory '%s': %s"
359 % (self, sys.exc_info()[1]),
359 % (self, sys.exc_info()[1]),
360 TreeWalkWarning)
360 TreeWalkWarning)
361 return
361 return
362 else:
362 else:
363 raise
363 raise
364
364
365 for child in childList:
365 for child in childList:
366 if pattern is None or child.fnmatch(pattern):
366 if pattern is None or child.fnmatch(pattern):
367 yield child
367 yield child
368 try:
368 try:
369 isdir = child.isdir()
369 isdir = child.isdir()
370 except Exception:
370 except Exception:
371 if errors == 'ignore':
371 if errors == 'ignore':
372 isdir = False
372 isdir = False
373 elif errors == 'warn':
373 elif errors == 'warn':
374 warnings.warn(
374 warnings.warn(
375 "Unable to access '%s': %s"
375 "Unable to access '%s': %s"
376 % (child, sys.exc_info()[1]),
376 % (child, sys.exc_info()[1]),
377 TreeWalkWarning)
377 TreeWalkWarning)
378 isdir = False
378 isdir = False
379 else:
379 else:
380 raise
380 raise
381
381
382 if isdir:
382 if isdir:
383 for item in child.walk(pattern, errors):
383 for item in child.walk(pattern, errors):
384 yield item
384 yield item
385
385
386 def walkdirs(self, pattern=None, errors='strict'):
386 def walkdirs(self, pattern=None, errors='strict'):
387 """ D.walkdirs() -> iterator over subdirs, recursively.
387 """ D.walkdirs() -> iterator over subdirs, recursively.
388
388
389 With the optional 'pattern' argument, this yields only
389 With the optional 'pattern' argument, this yields only
390 directories whose names match the given pattern. For
390 directories whose names match the given pattern. For
391 example, mydir.walkdirs('*test') yields only directories
391 example, mydir.walkdirs('*test') yields only directories
392 with names ending in 'test'.
392 with names ending in 'test'.
393
393
394 The errors= keyword argument controls behavior when an
394 The errors= keyword argument controls behavior when an
395 error occurs. The default is 'strict', which causes an
395 error occurs. The default is 'strict', which causes an
396 exception. The other allowed values are 'warn', which
396 exception. The other allowed values are 'warn', which
397 reports the error via warnings.warn(), and 'ignore'.
397 reports the error via warnings.warn(), and 'ignore'.
398 """
398 """
399 if errors not in ('strict', 'warn', 'ignore'):
399 if errors not in ('strict', 'warn', 'ignore'):
400 raise ValueError("invalid errors parameter")
400 raise ValueError("invalid errors parameter")
401
401
402 try:
402 try:
403 dirs = self.dirs()
403 dirs = self.dirs()
404 except Exception:
404 except Exception:
405 if errors == 'ignore':
405 if errors == 'ignore':
406 return
406 return
407 elif errors == 'warn':
407 elif errors == 'warn':
408 warnings.warn(
408 warnings.warn(
409 "Unable to list directory '%s': %s"
409 "Unable to list directory '%s': %s"
410 % (self, sys.exc_info()[1]),
410 % (self, sys.exc_info()[1]),
411 TreeWalkWarning)
411 TreeWalkWarning)
412 return
412 return
413 else:
413 else:
414 raise
414 raise
415
415
416 for child in dirs:
416 for child in dirs:
417 if pattern is None or child.fnmatch(pattern):
417 if pattern is None or child.fnmatch(pattern):
418 yield child
418 yield child
419 for subsubdir in child.walkdirs(pattern, errors):
419 for subsubdir in child.walkdirs(pattern, errors):
420 yield subsubdir
420 yield subsubdir
421
421
422 def walkfiles(self, pattern=None, errors='strict'):
422 def walkfiles(self, pattern=None, errors='strict'):
423 """ D.walkfiles() -> iterator over files in D, recursively.
423 """ D.walkfiles() -> iterator over files in D, recursively.
424
424
425 The optional argument, pattern, limits the results to files
425 The optional argument, pattern, limits the results to files
426 with names that match the pattern. For example,
426 with names that match the pattern. For example,
427 mydir.walkfiles('*.tmp') yields only files with the .tmp
427 mydir.walkfiles('*.tmp') yields only files with the .tmp
428 extension.
428 extension.
429 """
429 """
430 if errors not in ('strict', 'warn', 'ignore'):
430 if errors not in ('strict', 'warn', 'ignore'):
431 raise ValueError("invalid errors parameter")
431 raise ValueError("invalid errors parameter")
432
432
433 try:
433 try:
434 childList = self.listdir()
434 childList = self.listdir()
435 except Exception:
435 except Exception:
436 if errors == 'ignore':
436 if errors == 'ignore':
437 return
437 return
438 elif errors == 'warn':
438 elif errors == 'warn':
439 warnings.warn(
439 warnings.warn(
440 "Unable to list directory '%s': %s"
440 "Unable to list directory '%s': %s"
441 % (self, sys.exc_info()[1]),
441 % (self, sys.exc_info()[1]),
442 TreeWalkWarning)
442 TreeWalkWarning)
443 return
443 return
444 else:
444 else:
445 raise
445 raise
446
446
447 for child in childList:
447 for child in childList:
448 try:
448 try:
449 isfile = child.isfile()
449 isfile = child.isfile()
450 isdir = not isfile and child.isdir()
450 isdir = not isfile and child.isdir()
451 except:
451 except:
452 if errors == 'ignore':
452 if errors == 'ignore':
453 continue
453 continue
454 elif errors == 'warn':
454 elif errors == 'warn':
455 warnings.warn(
455 warnings.warn(
456 "Unable to access '%s': %s"
456 "Unable to access '%s': %s"
457 % (self, sys.exc_info()[1]),
457 % (self, sys.exc_info()[1]),
458 TreeWalkWarning)
458 TreeWalkWarning)
459 continue
459 continue
460 else:
460 else:
461 raise
461 raise
462
462
463 if isfile:
463 if isfile:
464 if pattern is None or child.fnmatch(pattern):
464 if pattern is None or child.fnmatch(pattern):
465 yield child
465 yield child
466 elif isdir:
466 elif isdir:
467 for f in child.walkfiles(pattern, errors):
467 for f in child.walkfiles(pattern, errors):
468 yield f
468 yield f
469
469
470 def fnmatch(self, pattern):
470 def fnmatch(self, pattern):
471 """ Return True if self.name matches the given pattern.
471 """ Return True if self.name matches the given pattern.
472
472
473 pattern - A filename pattern with wildcards,
473 pattern - A filename pattern with wildcards,
474 for example '*.py'.
474 for example '*.py'.
475 """
475 """
476 return fnmatch.fnmatch(self.name, pattern)
476 return fnmatch.fnmatch(self.name, pattern)
477
477
478 def glob(self, pattern):
478 def glob(self, pattern):
479 """ Return a list of path objects that match the pattern.
479 """ Return a list of path objects that match the pattern.
480
480
481 pattern - a path relative to this directory, with wildcards.
481 pattern - a path relative to this directory, with wildcards.
482
482
483 For example, path('/users').glob('*/bin/*') returns a list
483 For example, path('/users').glob('*/bin/*') returns a list
484 of all the files users have in their bin directories.
484 of all the files users have in their bin directories.
485 """
485 """
486 cls = self.__class__
486 cls = self.__class__
487 return [cls(s) for s in glob.glob(unicode(self / pattern))]
487 return [cls(s) for s in glob.glob(unicode(self / pattern))]
488
488
489
489
490 # --- Reading or writing an entire file at once.
490 # --- Reading or writing an entire file at once.
491
491
492 def open(self, mode='r'):
492 def open(self, mode='r'):
493 """ Open this file. Return a file object. """
493 """ Open this file. Return a file object. """
494 return open(self, mode)
494 return open(self, mode)
495
495
496 def bytes(self):
496 def bytes(self):
497 """ Open this file, read all bytes, return them as a string. """
497 """ Open this file, read all bytes, return them as a string. """
498 f = self.open('rb')
498 f = self.open('rb')
499 try:
499 try:
500 return f.read()
500 return f.read()
501 finally:
501 finally:
502 f.close()
502 f.close()
503
503
504 def write_bytes(self, bytes, append=False):
504 def write_bytes(self, bytes, append=False):
505 """ Open this file and write the given bytes to it.
505 """ Open this file and write the given bytes to it.
506
506
507 Default behavior is to overwrite any existing file.
507 Default behavior is to overwrite any existing file.
508 Call p.write_bytes(bytes, append=True) to append instead.
508 Call p.write_bytes(bytes, append=True) to append instead.
509 """
509 """
510 if append:
510 if append:
511 mode = 'ab'
511 mode = 'ab'
512 else:
512 else:
513 mode = 'wb'
513 mode = 'wb'
514 f = self.open(mode)
514 f = self.open(mode)
515 try:
515 try:
516 f.write(bytes)
516 f.write(bytes)
517 finally:
517 finally:
518 f.close()
518 f.close()
519
519
520 def text(self, encoding=None, errors='strict'):
520 def text(self, encoding=None, errors='strict'):
521 r""" Open this file, read it in, return the content as a string.
521 r""" Open this file, read it in, return the content as a string.
522
522
523 This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r'
523 This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r'
524 are automatically translated to '\n'.
524 are automatically translated to '\n'.
525
525
526 Optional arguments:
526 Optional arguments:
527
527
528 encoding - The Unicode encoding (or character set) of
528 encoding - The Unicode encoding (or character set) of
529 the file. If present, the content of the file is
529 the file. If present, the content of the file is
530 decoded and returned as a unicode object; otherwise
530 decoded and returned as a unicode object; otherwise
531 it is returned as an 8-bit str.
531 it is returned as an 8-bit str.
532 errors - How to handle Unicode errors; see help(str.decode)
532 errors - How to handle Unicode errors; see help(str.decode)
533 for the options. Default is 'strict'.
533 for the options. Default is 'strict'.
534 """
534 """
535 if encoding is None:
535 if encoding is None:
536 # 8-bit
536 # 8-bit
537 f = self.open('U')
537 f = self.open('U')
538 try:
538 try:
539 return f.read()
539 return f.read()
540 finally:
540 finally:
541 f.close()
541 f.close()
542 else:
542 else:
543 # Unicode
543 # Unicode
544 f = codecs.open(self, 'r', encoding, errors)
544 f = codecs.open(self, 'r', encoding, errors)
545 # (Note - Can't use 'U' mode here, since codecs.open
545 # (Note - Can't use 'U' mode here, since codecs.open
546 # doesn't support 'U' mode, even in Python 2.3.)
546 # doesn't support 'U' mode, even in Python 2.3.)
547 try:
547 try:
548 t = f.read()
548 t = f.read()
549 finally:
549 finally:
550 f.close()
550 f.close()
551 return (t.replace(u'\r\n', u'\n')
551 return (t.replace(u'\r\n', u'\n')
552 .replace(u'\r\x85', u'\n')
552 .replace(u'\r\x85', u'\n')
553 .replace(u'\r', u'\n')
553 .replace(u'\r', u'\n')
554 .replace(u'\x85', u'\n')
554 .replace(u'\x85', u'\n')
555 .replace(u'\u2028', u'\n'))
555 .replace(u'\u2028', u'\n'))
556
556
557 def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False):
557 def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False):
558 r""" Write the given text to this file.
558 r""" Write the given text to this file.
559
559
560 The default behavior is to overwrite any existing file;
560 The default behavior is to overwrite any existing file;
561 to append instead, use the 'append=True' keyword argument.
561 to append instead, use the 'append=True' keyword argument.
562
562
563 There are two differences between path.write_text() and
563 There are two differences between path.write_text() and
564 path.write_bytes(): newline handling and Unicode handling.
564 path.write_bytes(): newline handling and Unicode handling.
565 See below.
565 See below.
566
566
567 Parameters:
567 Parameters:
568
568
569 - text - str/unicode - The text to be written.
569 - text - str/unicode - The text to be written.
570
570
571 - encoding - str - The Unicode encoding that will be used.
571 - encoding - str - The Unicode encoding that will be used.
572 This is ignored if 'text' isn't a Unicode string.
572 This is ignored if 'text' isn't a Unicode string.
573
573
574 - errors - str - How to handle Unicode encoding errors.
574 - errors - str - How to handle Unicode encoding errors.
575 Default is 'strict'. See help(unicode.encode) for the
575 Default is 'strict'. See help(unicode.encode) for the
576 options. This is ignored if 'text' isn't a Unicode
576 options. This is ignored if 'text' isn't a Unicode
577 string.
577 string.
578
578
579 - linesep - keyword argument - str/unicode - The sequence of
579 - linesep - keyword argument - str/unicode - The sequence of
580 characters to be used to mark end-of-line. The default is
580 characters to be used to mark end-of-line. The default is
581 os.linesep. You can also specify None; this means to
581 os.linesep. You can also specify None; this means to
582 leave all newlines as they are in 'text'.
582 leave all newlines as they are in 'text'.
583
583
584 - append - keyword argument - bool - Specifies what to do if
584 - append - keyword argument - bool - Specifies what to do if
585 the file already exists (True: append to the end of it;
585 the file already exists (True: append to the end of it;
586 False: overwrite it.) The default is False.
586 False: overwrite it.) The default is False.
587
587
588
588
589 --- Newline handling.
589 --- Newline handling.
590
590
591 write_text() converts all standard end-of-line sequences
591 write_text() converts all standard end-of-line sequences
592 ('\n', '\r', and '\r\n') to your platform's default end-of-line
592 ('\n', '\r', and '\r\n') to your platform's default end-of-line
593 sequence (see os.linesep; on Windows, for example, the
593 sequence (see os.linesep; on Windows, for example, the
594 end-of-line marker is '\r\n').
594 end-of-line marker is '\r\n').
595
595
596 If you don't like your platform's default, you can override it
596 If you don't like your platform's default, you can override it
597 using the 'linesep=' keyword argument. If you specifically want
597 using the 'linesep=' keyword argument. If you specifically want
598 write_text() to preserve the newlines as-is, use 'linesep=None'.
598 write_text() to preserve the newlines as-is, use 'linesep=None'.
599
599
600 This applies to Unicode text the same as to 8-bit text, except
600 This applies to Unicode text the same as to 8-bit text, except
601 there are three additional standard Unicode end-of-line sequences:
601 there are three additional standard Unicode end-of-line sequences:
602 u'\x85', u'\r\x85', and u'\u2028'.
602 u'\x85', u'\r\x85', and u'\u2028'.
603
603
604 (This is slightly different from when you open a file for
604 (This is slightly different from when you open a file for
605 writing with fopen(filename, "w") in C or file(filename, 'w')
605 writing with fopen(filename, "w") in C or open(filename, 'w')
606 in Python.)
606 in Python.)
607
607
608
608
609 --- Unicode
609 --- Unicode
610
610
611 If 'text' isn't Unicode, then apart from newline handling, the
611 If 'text' isn't Unicode, then apart from newline handling, the
612 bytes are written verbatim to the file. The 'encoding' and
612 bytes are written verbatim to the file. The 'encoding' and
613 'errors' arguments are not used and must be omitted.
613 'errors' arguments are not used and must be omitted.
614
614
615 If 'text' is Unicode, it is first converted to bytes using the
615 If 'text' is Unicode, it is first converted to bytes using the
616 specified 'encoding' (or the default encoding if 'encoding'
616 specified 'encoding' (or the default encoding if 'encoding'
617 isn't specified). The 'errors' argument applies only to this
617 isn't specified). The 'errors' argument applies only to this
618 conversion.
618 conversion.
619
619
620 """
620 """
621 if isinstance(text, unicode):
621 if isinstance(text, unicode):
622 if linesep is not None:
622 if linesep is not None:
623 # Convert all standard end-of-line sequences to
623 # Convert all standard end-of-line sequences to
624 # ordinary newline characters.
624 # ordinary newline characters.
625 text = (text.replace(u'\r\n', u'\n')
625 text = (text.replace(u'\r\n', u'\n')
626 .replace(u'\r\x85', u'\n')
626 .replace(u'\r\x85', u'\n')
627 .replace(u'\r', u'\n')
627 .replace(u'\r', u'\n')
628 .replace(u'\x85', u'\n')
628 .replace(u'\x85', u'\n')
629 .replace(u'\u2028', u'\n'))
629 .replace(u'\u2028', u'\n'))
630 text = text.replace(u'\n', linesep)
630 text = text.replace(u'\n', linesep)
631 if encoding is None:
631 if encoding is None:
632 encoding = sys.getdefaultencoding()
632 encoding = sys.getdefaultencoding()
633 bytes = text.encode(encoding, errors)
633 bytes = text.encode(encoding, errors)
634 else:
634 else:
635 # It is an error to specify an encoding if 'text' is
635 # It is an error to specify an encoding if 'text' is
636 # an 8-bit string.
636 # an 8-bit string.
637 assert encoding is None
637 assert encoding is None
638
638
639 if linesep is not None:
639 if linesep is not None:
640 text = (text.replace('\r\n', '\n')
640 text = (text.replace('\r\n', '\n')
641 .replace('\r', '\n'))
641 .replace('\r', '\n'))
642 bytes = text.replace('\n', linesep)
642 bytes = text.replace('\n', linesep)
643
643
644 self.write_bytes(bytes, append)
644 self.write_bytes(bytes, append)
645
645
646 def lines(self, encoding=None, errors='strict', retain=True):
646 def lines(self, encoding=None, errors='strict', retain=True):
647 r""" Open this file, read all lines, return them in a list.
647 r""" Open this file, read all lines, return them in a list.
648
648
649 Optional arguments:
649 Optional arguments:
650 encoding - The Unicode encoding (or character set) of
650 encoding - The Unicode encoding (or character set) of
651 the file. The default is None, meaning the content
651 the file. The default is None, meaning the content
652 of the file is read as 8-bit characters and returned
652 of the file is read as 8-bit characters and returned
653 as a list of (non-Unicode) str objects.
653 as a list of (non-Unicode) str objects.
654 errors - How to handle Unicode errors; see help(str.decode)
654 errors - How to handle Unicode errors; see help(str.decode)
655 for the options. Default is 'strict'
655 for the options. Default is 'strict'
656 retain - If true, retain newline characters; but all newline
656 retain - If true, retain newline characters; but all newline
657 character combinations ('\r', '\n', '\r\n') are
657 character combinations ('\r', '\n', '\r\n') are
658 translated to '\n'. If false, newline characters are
658 translated to '\n'. If false, newline characters are
659 stripped off. Default is True.
659 stripped off. Default is True.
660
660
661 This uses 'U' mode in Python 2.3 and later.
661 This uses 'U' mode in Python 2.3 and later.
662 """
662 """
663 if encoding is None and retain:
663 if encoding is None and retain:
664 f = self.open('U')
664 f = self.open('U')
665 try:
665 try:
666 return f.readlines()
666 return f.readlines()
667 finally:
667 finally:
668 f.close()
668 f.close()
669 else:
669 else:
670 return self.text(encoding, errors).splitlines(retain)
670 return self.text(encoding, errors).splitlines(retain)
671
671
672 def write_lines(self, lines, encoding=None, errors='strict',
672 def write_lines(self, lines, encoding=None, errors='strict',
673 linesep=os.linesep, append=False):
673 linesep=os.linesep, append=False):
674 r""" Write the given lines of text to this file.
674 r""" Write the given lines of text to this file.
675
675
676 By default this overwrites any existing file at this path.
676 By default this overwrites any existing file at this path.
677
677
678 This puts a platform-specific newline sequence on every line.
678 This puts a platform-specific newline sequence on every line.
679 See 'linesep' below.
679 See 'linesep' below.
680
680
681 lines - A list of strings.
681 lines - A list of strings.
682
682
683 encoding - A Unicode encoding to use. This applies only if
683 encoding - A Unicode encoding to use. This applies only if
684 'lines' contains any Unicode strings.
684 'lines' contains any Unicode strings.
685
685
686 errors - How to handle errors in Unicode encoding. This
686 errors - How to handle errors in Unicode encoding. This
687 also applies only to Unicode strings.
687 also applies only to Unicode strings.
688
688
689 linesep - The desired line-ending. This line-ending is
689 linesep - The desired line-ending. This line-ending is
690 applied to every line. If a line already has any
690 applied to every line. If a line already has any
691 standard line ending ('\r', '\n', '\r\n', u'\x85',
691 standard line ending ('\r', '\n', '\r\n', u'\x85',
692 u'\r\x85', u'\u2028'), that will be stripped off and
692 u'\r\x85', u'\u2028'), that will be stripped off and
693 this will be used instead. The default is os.linesep,
693 this will be used instead. The default is os.linesep,
694 which is platform-dependent ('\r\n' on Windows, '\n' on
694 which is platform-dependent ('\r\n' on Windows, '\n' on
695 Unix, etc.) Specify None to write the lines as-is,
695 Unix, etc.) Specify None to write the lines as-is,
696 like file.writelines().
696 like file.writelines().
697
697
698 Use the keyword argument append=True to append lines to the
698 Use the keyword argument append=True to append lines to the
699 file. The default is to overwrite the file. Warning:
699 file. The default is to overwrite the file. Warning:
700 When you use this with Unicode data, if the encoding of the
700 When you use this with Unicode data, if the encoding of the
701 existing data in the file is different from the encoding
701 existing data in the file is different from the encoding
702 you specify with the encoding= parameter, the result is
702 you specify with the encoding= parameter, the result is
703 mixed-encoding data, which can really confuse someone trying
703 mixed-encoding data, which can really confuse someone trying
704 to read the file later.
704 to read the file later.
705 """
705 """
706 if append:
706 if append:
707 mode = 'ab'
707 mode = 'ab'
708 else:
708 else:
709 mode = 'wb'
709 mode = 'wb'
710 f = self.open(mode)
710 f = self.open(mode)
711 try:
711 try:
712 for line in lines:
712 for line in lines:
713 isUnicode = isinstance(line, unicode)
713 isUnicode = isinstance(line, unicode)
714 if linesep is not None:
714 if linesep is not None:
715 # Strip off any existing line-end and add the
715 # Strip off any existing line-end and add the
716 # specified linesep string.
716 # specified linesep string.
717 if isUnicode:
717 if isUnicode:
718 if line[-2:] in (u'\r\n', u'\x0d\x85'):
718 if line[-2:] in (u'\r\n', u'\x0d\x85'):
719 line = line[:-2]
719 line = line[:-2]
720 elif line[-1:] in (u'\r', u'\n',
720 elif line[-1:] in (u'\r', u'\n',
721 u'\x85', u'\u2028'):
721 u'\x85', u'\u2028'):
722 line = line[:-1]
722 line = line[:-1]
723 else:
723 else:
724 if line[-2:] == '\r\n':
724 if line[-2:] == '\r\n':
725 line = line[:-2]
725 line = line[:-2]
726 elif line[-1:] in ('\r', '\n'):
726 elif line[-1:] in ('\r', '\n'):
727 line = line[:-1]
727 line = line[:-1]
728 line += linesep
728 line += linesep
729 if isUnicode:
729 if isUnicode:
730 if encoding is None:
730 if encoding is None:
731 encoding = sys.getdefaultencoding()
731 encoding = sys.getdefaultencoding()
732 line = line.encode(encoding, errors)
732 line = line.encode(encoding, errors)
733 f.write(line)
733 f.write(line)
734 finally:
734 finally:
735 f.close()
735 f.close()
736
736
737 def read_md5(self):
737 def read_md5(self):
738 """ Calculate the md5 hash for this file.
738 """ Calculate the md5 hash for this file.
739
739
740 This reads through the entire file.
740 This reads through the entire file.
741 """
741 """
742 f = self.open('rb')
742 f = self.open('rb')
743 try:
743 try:
744 m = md5()
744 m = md5()
745 while True:
745 while True:
746 d = f.read(8192)
746 d = f.read(8192)
747 if not d:
747 if not d:
748 break
748 break
749 m.update(d)
749 m.update(d)
750 finally:
750 finally:
751 f.close()
751 f.close()
752 return m.digest()
752 return m.digest()
753
753
754 # --- Methods for querying the filesystem.
754 # --- Methods for querying the filesystem.
755 # N.B. We can't assign the functions directly, because they may on some
755 # N.B. We can't assign the functions directly, because they may on some
756 # platforms be implemented in C, and compiled functions don't get bound.
756 # platforms be implemented in C, and compiled functions don't get bound.
757 # See gh-737 for discussion of this.
757 # See gh-737 for discussion of this.
758
758
759 def exists(s): return os.path.exists(s)
759 def exists(s): return os.path.exists(s)
760 def isdir(s): return os.path.isdir(s)
760 def isdir(s): return os.path.isdir(s)
761 def isfile(s): return os.path.isfile(s)
761 def isfile(s): return os.path.isfile(s)
762 def islink(s): return os.path.islink(s)
762 def islink(s): return os.path.islink(s)
763 def ismount(s): return os.path.ismount(s)
763 def ismount(s): return os.path.ismount(s)
764
764
765 if hasattr(os.path, 'samefile'):
765 if hasattr(os.path, 'samefile'):
766 def samefile(s, o): return os.path.samefile(s, o)
766 def samefile(s, o): return os.path.samefile(s, o)
767
767
768 def getatime(s): return os.path.getatime(s)
768 def getatime(s): return os.path.getatime(s)
769 atime = property(
769 atime = property(
770 getatime, None, None,
770 getatime, None, None,
771 """ Last access time of the file. """)
771 """ Last access time of the file. """)
772
772
773 def getmtime(s): return os.path.getmtime(s)
773 def getmtime(s): return os.path.getmtime(s)
774 mtime = property(
774 mtime = property(
775 getmtime, None, None,
775 getmtime, None, None,
776 """ Last-modified time of the file. """)
776 """ Last-modified time of the file. """)
777
777
778 if hasattr(os.path, 'getctime'):
778 if hasattr(os.path, 'getctime'):
779 def getctime(s): return os.path.getctime(s)
779 def getctime(s): return os.path.getctime(s)
780 ctime = property(
780 ctime = property(
781 getctime, None, None,
781 getctime, None, None,
782 """ Creation time of the file. """)
782 """ Creation time of the file. """)
783
783
784 def getsize(s): return os.path.getsize(s)
784 def getsize(s): return os.path.getsize(s)
785 size = property(
785 size = property(
786 getsize, None, None,
786 getsize, None, None,
787 """ Size of the file, in bytes. """)
787 """ Size of the file, in bytes. """)
788
788
789 if hasattr(os, 'access'):
789 if hasattr(os, 'access'):
790 def access(self, mode):
790 def access(self, mode):
791 """ Return true if current user has access to this path.
791 """ Return true if current user has access to this path.
792
792
793 mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK
793 mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK
794 """
794 """
795 return os.access(self, mode)
795 return os.access(self, mode)
796
796
797 def stat(self):
797 def stat(self):
798 """ Perform a stat() system call on this path. """
798 """ Perform a stat() system call on this path. """
799 return os.stat(self)
799 return os.stat(self)
800
800
801 def lstat(self):
801 def lstat(self):
802 """ Like path.stat(), but do not follow symbolic links. """
802 """ Like path.stat(), but do not follow symbolic links. """
803 return os.lstat(self)
803 return os.lstat(self)
804
804
805 def get_owner(self):
805 def get_owner(self):
806 r""" Return the name of the owner of this file or directory.
806 r""" Return the name of the owner of this file or directory.
807
807
808 This follows symbolic links.
808 This follows symbolic links.
809
809
810 On Windows, this returns a name of the form ur'DOMAIN\User Name'.
810 On Windows, this returns a name of the form ur'DOMAIN\User Name'.
811 On Windows, a group can own a file or directory.
811 On Windows, a group can own a file or directory.
812 """
812 """
813 if os.name == 'nt':
813 if os.name == 'nt':
814 if win32security is None:
814 if win32security is None:
815 raise Exception("path.owner requires win32all to be installed")
815 raise Exception("path.owner requires win32all to be installed")
816 desc = win32security.GetFileSecurity(
816 desc = win32security.GetFileSecurity(
817 self, win32security.OWNER_SECURITY_INFORMATION)
817 self, win32security.OWNER_SECURITY_INFORMATION)
818 sid = desc.GetSecurityDescriptorOwner()
818 sid = desc.GetSecurityDescriptorOwner()
819 account, domain, typecode = win32security.LookupAccountSid(None, sid)
819 account, domain, typecode = win32security.LookupAccountSid(None, sid)
820 return domain + u'\\' + account
820 return domain + u'\\' + account
821 else:
821 else:
822 if pwd is None:
822 if pwd is None:
823 raise NotImplementedError("path.owner is not implemented on this platform.")
823 raise NotImplementedError("path.owner is not implemented on this platform.")
824 st = self.stat()
824 st = self.stat()
825 return pwd.getpwuid(st.st_uid).pw_name
825 return pwd.getpwuid(st.st_uid).pw_name
826
826
827 owner = property(
827 owner = property(
828 get_owner, None, None,
828 get_owner, None, None,
829 """ Name of the owner of this file or directory. """)
829 """ Name of the owner of this file or directory. """)
830
830
831 if hasattr(os, 'statvfs'):
831 if hasattr(os, 'statvfs'):
832 def statvfs(self):
832 def statvfs(self):
833 """ Perform a statvfs() system call on this path. """
833 """ Perform a statvfs() system call on this path. """
834 return os.statvfs(self)
834 return os.statvfs(self)
835
835
836 if hasattr(os, 'pathconf'):
836 if hasattr(os, 'pathconf'):
837 def pathconf(self, name):
837 def pathconf(self, name):
838 return os.pathconf(self, name)
838 return os.pathconf(self, name)
839
839
840
840
841 # --- Modifying operations on files and directories
841 # --- Modifying operations on files and directories
842
842
843 def utime(self, times):
843 def utime(self, times):
844 """ Set the access and modified times of this file. """
844 """ Set the access and modified times of this file. """
845 os.utime(self, times)
845 os.utime(self, times)
846
846
847 def chmod(self, mode):
847 def chmod(self, mode):
848 os.chmod(self, mode)
848 os.chmod(self, mode)
849
849
850 if hasattr(os, 'chown'):
850 if hasattr(os, 'chown'):
851 def chown(self, uid, gid):
851 def chown(self, uid, gid):
852 os.chown(self, uid, gid)
852 os.chown(self, uid, gid)
853
853
854 def rename(self, new):
854 def rename(self, new):
855 os.rename(self, new)
855 os.rename(self, new)
856
856
857 def renames(self, new):
857 def renames(self, new):
858 os.renames(self, new)
858 os.renames(self, new)
859
859
860
860
861 # --- Create/delete operations on directories
861 # --- Create/delete operations on directories
862
862
863 def mkdir(self, mode=0777):
863 def mkdir(self, mode=0777):
864 os.mkdir(self, mode)
864 os.mkdir(self, mode)
865
865
866 def makedirs(self, mode=0777):
866 def makedirs(self, mode=0777):
867 os.makedirs(self, mode)
867 os.makedirs(self, mode)
868
868
869 def rmdir(self):
869 def rmdir(self):
870 os.rmdir(self)
870 os.rmdir(self)
871
871
872 def removedirs(self):
872 def removedirs(self):
873 os.removedirs(self)
873 os.removedirs(self)
874
874
875
875
876 # --- Modifying operations on files
876 # --- Modifying operations on files
877
877
878 def touch(self):
878 def touch(self):
879 """ Set the access/modified times of this file to the current time.
879 """ Set the access/modified times of this file to the current time.
880 Create the file if it does not exist.
880 Create the file if it does not exist.
881 """
881 """
882 fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
882 fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
883 os.close(fd)
883 os.close(fd)
884 os.utime(self, None)
884 os.utime(self, None)
885
885
886 def remove(self):
886 def remove(self):
887 os.remove(self)
887 os.remove(self)
888
888
889 def unlink(self):
889 def unlink(self):
890 os.unlink(self)
890 os.unlink(self)
891
891
892
892
893 # --- Links
893 # --- Links
894
894
895 if hasattr(os, 'link'):
895 if hasattr(os, 'link'):
896 def link(self, newpath):
896 def link(self, newpath):
897 """ Create a hard link at 'newpath', pointing to this file. """
897 """ Create a hard link at 'newpath', pointing to this file. """
898 os.link(self, newpath)
898 os.link(self, newpath)
899
899
900 if hasattr(os, 'symlink'):
900 if hasattr(os, 'symlink'):
901 def symlink(self, newlink):
901 def symlink(self, newlink):
902 """ Create a symbolic link at 'newlink', pointing here. """
902 """ Create a symbolic link at 'newlink', pointing here. """
903 os.symlink(self, newlink)
903 os.symlink(self, newlink)
904
904
905 if hasattr(os, 'readlink'):
905 if hasattr(os, 'readlink'):
906 def readlink(self):
906 def readlink(self):
907 """ Return the path to which this symbolic link points.
907 """ Return the path to which this symbolic link points.
908
908
909 The result may be an absolute or a relative path.
909 The result may be an absolute or a relative path.
910 """
910 """
911 return self.__class__(os.readlink(self))
911 return self.__class__(os.readlink(self))
912
912
913 def readlinkabs(self):
913 def readlinkabs(self):
914 """ Return the path to which this symbolic link points.
914 """ Return the path to which this symbolic link points.
915
915
916 The result is always an absolute path.
916 The result is always an absolute path.
917 """
917 """
918 p = self.readlink()
918 p = self.readlink()
919 if p.isabs():
919 if p.isabs():
920 return p
920 return p
921 else:
921 else:
922 return (self.parent / p).abspath()
922 return (self.parent / p).abspath()
923
923
924
924
925 # --- High-level functions from shutil
925 # --- High-level functions from shutil
926
926
927 copyfile = shutil.copyfile
927 copyfile = shutil.copyfile
928 copymode = shutil.copymode
928 copymode = shutil.copymode
929 copystat = shutil.copystat
929 copystat = shutil.copystat
930 copy = shutil.copy
930 copy = shutil.copy
931 copy2 = shutil.copy2
931 copy2 = shutil.copy2
932 copytree = shutil.copytree
932 copytree = shutil.copytree
933 if hasattr(shutil, 'move'):
933 if hasattr(shutil, 'move'):
934 move = shutil.move
934 move = shutil.move
935 rmtree = shutil.rmtree
935 rmtree = shutil.rmtree
936
936
937
937
938 # --- Special stuff from os
938 # --- Special stuff from os
939
939
940 if hasattr(os, 'chroot'):
940 if hasattr(os, 'chroot'):
941 def chroot(self):
941 def chroot(self):
942 os.chroot(self)
942 os.chroot(self)
943
943
944 if hasattr(os, 'startfile'):
944 if hasattr(os, 'startfile'):
945 def startfile(self):
945 def startfile(self):
946 os.startfile(self)
946 os.startfile(self)
947
947
@@ -1,1900 +1,1900 b''
1 """Pexpect is a Python module for spawning child applications and controlling
1 """Pexpect is a Python module for spawning child applications and controlling
2 them automatically. Pexpect can be used for automating interactive applications
2 them automatically. Pexpect can be used for automating interactive applications
3 such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup
3 such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup
4 scripts for duplicating software package installations on different servers. It
4 scripts for duplicating software package installations on different servers. It
5 can be used for automated software testing. Pexpect is in the spirit of Don
5 can be used for automated software testing. Pexpect is in the spirit of Don
6 Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python
6 Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python
7 require TCL and Expect or require C extensions to be compiled. Pexpect does not
7 require TCL and Expect or require C extensions to be compiled. Pexpect does not
8 use C, Expect, or TCL extensions. It should work on any platform that supports
8 use C, Expect, or TCL extensions. It should work on any platform that supports
9 the standard Python pty module. The Pexpect interface focuses on ease of use so
9 the standard Python pty module. The Pexpect interface focuses on ease of use so
10 that simple tasks are easy.
10 that simple tasks are easy.
11
11
12 There are two main interfaces to the Pexpect system; these are the function,
12 There are two main interfaces to the Pexpect system; these are the function,
13 run() and the class, spawn. The spawn class is more powerful. The run()
13 run() and the class, spawn. The spawn class is more powerful. The run()
14 function is simpler than spawn, and is good for quickly calling program. When
14 function is simpler than spawn, and is good for quickly calling program. When
15 you call the run() function it executes a given program and then returns the
15 you call the run() function it executes a given program and then returns the
16 output. This is a handy replacement for os.system().
16 output. This is a handy replacement for os.system().
17
17
18 For example::
18 For example::
19
19
20 pexpect.run('ls -la')
20 pexpect.run('ls -la')
21
21
22 The spawn class is the more powerful interface to the Pexpect system. You can
22 The spawn class is the more powerful interface to the Pexpect system. You can
23 use this to spawn a child program then interact with it by sending input and
23 use this to spawn a child program then interact with it by sending input and
24 expecting responses (waiting for patterns in the child's output).
24 expecting responses (waiting for patterns in the child's output).
25
25
26 For example::
26 For example::
27
27
28 child = pexpect.spawn('scp foo myname@host.example.com:.')
28 child = pexpect.spawn('scp foo myname@host.example.com:.')
29 child.expect ('Password:')
29 child.expect ('Password:')
30 child.sendline (mypassword)
30 child.sendline (mypassword)
31
31
32 This works even for commands that ask for passwords or other input outside of
32 This works even for commands that ask for passwords or other input outside of
33 the normal stdio streams. For example, ssh reads input directly from the TTY
33 the normal stdio streams. For example, ssh reads input directly from the TTY
34 device which bypasses stdin.
34 device which bypasses stdin.
35
35
36 Credits: Noah Spurrier, Richard Holden, Marco Molteni, Kimberley Burchett,
36 Credits: Noah Spurrier, Richard Holden, Marco Molteni, Kimberley Burchett,
37 Robert Stone, Hartmut Goebel, Chad Schroeder, Erick Tryzelaar, Dave Kirby, Ids
37 Robert Stone, Hartmut Goebel, Chad Schroeder, Erick Tryzelaar, Dave Kirby, Ids
38 vander Molen, George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin,
38 vander Molen, George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin,
39 Jacques-Etienne Baudoux, Geoffrey Marshall, Francisco Lourenco, Glen Mabey,
39 Jacques-Etienne Baudoux, Geoffrey Marshall, Francisco Lourenco, Glen Mabey,
40 Karthik Gurusamy, Fernando Perez, Corey Minyard, Jon Cohen, Guillaume
40 Karthik Gurusamy, Fernando Perez, Corey Minyard, Jon Cohen, Guillaume
41 Chazarain, Andrew Ryan, Nick Craig-Wood, Andrew Stone, Jorgen Grahn, John
41 Chazarain, Andrew Ryan, Nick Craig-Wood, Andrew Stone, Jorgen Grahn, John
42 Spiegel, Jan Grant, Shane Kerr and Thomas Kluyver. Let me know if I forgot anyone.
42 Spiegel, Jan Grant, Shane Kerr and Thomas Kluyver. Let me know if I forgot anyone.
43
43
44 Pexpect is free, open source, and all that good stuff.
44 Pexpect is free, open source, and all that good stuff.
45
45
46 Permission is hereby granted, free of charge, to any person obtaining a copy of
46 Permission is hereby granted, free of charge, to any person obtaining a copy of
47 this software and associated documentation files (the "Software"), to deal in
47 this software and associated documentation files (the "Software"), to deal in
48 the Software without restriction, including without limitation the rights to
48 the Software without restriction, including without limitation the rights to
49 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
49 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
50 of the Software, and to permit persons to whom the Software is furnished to do
50 of the Software, and to permit persons to whom the Software is furnished to do
51 so, subject to the following conditions:
51 so, subject to the following conditions:
52
52
53 The above copyright notice and this permission notice shall be included in all
53 The above copyright notice and this permission notice shall be included in all
54 copies or substantial portions of the Software.
54 copies or substantial portions of the Software.
55
55
56 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
56 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
57 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
57 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
58 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
58 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
59 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
59 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
60 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
60 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
61 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
61 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
62 SOFTWARE.
62 SOFTWARE.
63
63
64 Pexpect Copyright (c) 2008-2011 Noah Spurrier
64 Pexpect Copyright (c) 2008-2011 Noah Spurrier
65 http://pexpect.sourceforge.net/
65 http://pexpect.sourceforge.net/
66 """
66 """
67
67
68 try:
68 try:
69 import os, sys, time
69 import os, sys, time
70 import select
70 import select
71 import re
71 import re
72 import struct
72 import struct
73 import resource
73 import resource
74 import types
74 import types
75 import pty
75 import pty
76 import tty
76 import tty
77 import termios
77 import termios
78 import fcntl
78 import fcntl
79 import errno
79 import errno
80 import traceback
80 import traceback
81 import signal
81 import signal
82 except ImportError, e:
82 except ImportError, e:
83 raise ImportError (str(e) + """
83 raise ImportError (str(e) + """
84
84
85 A critical module was not found. Probably this operating system does not
85 A critical module was not found. Probably this operating system does not
86 support it. Pexpect is intended for UNIX-like operating systems.""")
86 support it. Pexpect is intended for UNIX-like operating systems.""")
87
87
88 __version__ = '2.6.dev'
88 __version__ = '2.6.dev'
89 version = __version__
89 version = __version__
90 version_info = (2,6,'dev')
90 version_info = (2,6,'dev')
91 __all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'spawnb', 'run', 'which',
91 __all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'spawnb', 'run', 'which',
92 'split_command_line', '__version__']
92 'split_command_line', '__version__']
93
93
94 # Exception classes used by this module.
94 # Exception classes used by this module.
95 class ExceptionPexpect(Exception):
95 class ExceptionPexpect(Exception):
96
96
97 """Base class for all exceptions raised by this module.
97 """Base class for all exceptions raised by this module.
98 """
98 """
99
99
100 def __init__(self, value):
100 def __init__(self, value):
101
101
102 self.value = value
102 self.value = value
103
103
104 def __str__(self):
104 def __str__(self):
105
105
106 return str(self.value)
106 return str(self.value)
107
107
108 def get_trace(self):
108 def get_trace(self):
109
109
110 """This returns an abbreviated stack trace with lines that only concern
110 """This returns an abbreviated stack trace with lines that only concern
111 the caller. In other words, the stack trace inside the Pexpect module
111 the caller. In other words, the stack trace inside the Pexpect module
112 is not included. """
112 is not included. """
113
113
114 tblist = traceback.extract_tb(sys.exc_info()[2])
114 tblist = traceback.extract_tb(sys.exc_info()[2])
115 #tblist = filter(self.__filter_not_pexpect, tblist)
115 #tblist = filter(self.__filter_not_pexpect, tblist)
116 tblist = [item for item in tblist if self.__filter_not_pexpect(item)]
116 tblist = [item for item in tblist if self.__filter_not_pexpect(item)]
117 tblist = traceback.format_list(tblist)
117 tblist = traceback.format_list(tblist)
118 return ''.join(tblist)
118 return ''.join(tblist)
119
119
120 def __filter_not_pexpect(self, trace_list_item):
120 def __filter_not_pexpect(self, trace_list_item):
121
121
122 """This returns True if list item 0 the string 'pexpect.py' in it. """
122 """This returns True if list item 0 the string 'pexpect.py' in it. """
123
123
124 if trace_list_item[0].find('pexpect.py') == -1:
124 if trace_list_item[0].find('pexpect.py') == -1:
125 return True
125 return True
126 else:
126 else:
127 return False
127 return False
128
128
129 class EOF(ExceptionPexpect):
129 class EOF(ExceptionPexpect):
130
130
131 """Raised when EOF is read from a child. This usually means the child has exited."""
131 """Raised when EOF is read from a child. This usually means the child has exited."""
132
132
133 class TIMEOUT(ExceptionPexpect):
133 class TIMEOUT(ExceptionPexpect):
134
134
135 """Raised when a read time exceeds the timeout. """
135 """Raised when a read time exceeds the timeout. """
136
136
137 ##class TIMEOUT_PATTERN(TIMEOUT):
137 ##class TIMEOUT_PATTERN(TIMEOUT):
138 ## """Raised when the pattern match time exceeds the timeout.
138 ## """Raised when the pattern match time exceeds the timeout.
139 ## This is different than a read TIMEOUT because the child process may
139 ## This is different than a read TIMEOUT because the child process may
140 ## give output, thus never give a TIMEOUT, but the output
140 ## give output, thus never give a TIMEOUT, but the output
141 ## may never match a pattern.
141 ## may never match a pattern.
142 ## """
142 ## """
143 ##class MAXBUFFER(ExceptionPexpect):
143 ##class MAXBUFFER(ExceptionPexpect):
144 ## """Raised when a scan buffer fills before matching an expected pattern."""
144 ## """Raised when a scan buffer fills before matching an expected pattern."""
145
145
146 PY3 = (sys.version_info[0] >= 3)
146 PY3 = (sys.version_info[0] >= 3)
147
147
148 def _cast_bytes(s, enc):
148 def _cast_bytes(s, enc):
149 if isinstance(s, unicode):
149 if isinstance(s, unicode):
150 return s.encode(enc)
150 return s.encode(enc)
151 return s
151 return s
152
152
153 def _cast_unicode(s, enc):
153 def _cast_unicode(s, enc):
154 if isinstance(s, bytes):
154 if isinstance(s, bytes):
155 return s.decode(enc)
155 return s.decode(enc)
156 return s
156 return s
157
157
158 re_type = type(re.compile(''))
158 re_type = type(re.compile(''))
159
159
160 def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None,
160 def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None,
161 logfile=None, cwd=None, env=None, encoding='utf-8'):
161 logfile=None, cwd=None, env=None, encoding='utf-8'):
162
162
163 """
163 """
164 This function runs the given command; waits for it to finish; then
164 This function runs the given command; waits for it to finish; then
165 returns all output as a string. STDERR is included in output. If the full
165 returns all output as a string. STDERR is included in output. If the full
166 path to the command is not given then the path is searched.
166 path to the command is not given then the path is searched.
167
167
168 Note that lines are terminated by CR/LF (\\r\\n) combination even on
168 Note that lines are terminated by CR/LF (\\r\\n) combination even on
169 UNIX-like systems because this is the standard for pseudo ttys. If you set
169 UNIX-like systems because this is the standard for pseudo ttys. If you set
170 'withexitstatus' to true, then run will return a tuple of (command_output,
170 'withexitstatus' to true, then run will return a tuple of (command_output,
171 exitstatus). If 'withexitstatus' is false then this returns just
171 exitstatus). If 'withexitstatus' is false then this returns just
172 command_output.
172 command_output.
173
173
174 The run() function can often be used instead of creating a spawn instance.
174 The run() function can often be used instead of creating a spawn instance.
175 For example, the following code uses spawn::
175 For example, the following code uses spawn::
176
176
177 from pexpect import *
177 from pexpect import *
178 child = spawn('scp foo myname@host.example.com:.')
178 child = spawn('scp foo myname@host.example.com:.')
179 child.expect ('(?i)password')
179 child.expect ('(?i)password')
180 child.sendline (mypassword)
180 child.sendline (mypassword)
181
181
182 The previous code can be replace with the following::
182 The previous code can be replace with the following::
183
183
184 from pexpect import *
184 from pexpect import *
185 run ('scp foo myname@host.example.com:.', events={'(?i)password': mypassword})
185 run ('scp foo myname@host.example.com:.', events={'(?i)password': mypassword})
186
186
187 Examples
187 Examples
188 ========
188 ========
189
189
190 Start the apache daemon on the local machine::
190 Start the apache daemon on the local machine::
191
191
192 from pexpect import *
192 from pexpect import *
193 run ("/usr/local/apache/bin/apachectl start")
193 run ("/usr/local/apache/bin/apachectl start")
194
194
195 Check in a file using SVN::
195 Check in a file using SVN::
196
196
197 from pexpect import *
197 from pexpect import *
198 run ("svn ci -m 'automatic commit' my_file.py")
198 run ("svn ci -m 'automatic commit' my_file.py")
199
199
200 Run a command and capture exit status::
200 Run a command and capture exit status::
201
201
202 from pexpect import *
202 from pexpect import *
203 (command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)
203 (command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)
204
204
205 Tricky Examples
205 Tricky Examples
206 ===============
206 ===============
207
207
208 The following will run SSH and execute 'ls -l' on the remote machine. The
208 The following will run SSH and execute 'ls -l' on the remote machine. The
209 password 'secret' will be sent if the '(?i)password' pattern is ever seen::
209 password 'secret' will be sent if the '(?i)password' pattern is ever seen::
210
210
211 run ("ssh username@machine.example.com 'ls -l'", events={'(?i)password':'secret\\n'})
211 run ("ssh username@machine.example.com 'ls -l'", events={'(?i)password':'secret\\n'})
212
212
213 This will start mencoder to rip a video from DVD. This will also display
213 This will start mencoder to rip a video from DVD. This will also display
214 progress ticks every 5 seconds as it runs. For example::
214 progress ticks every 5 seconds as it runs. For example::
215
215
216 from pexpect import *
216 from pexpect import *
217 def print_ticks(d):
217 def print_ticks(d):
218 print d['event_count'],
218 print d['event_count'],
219 run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={TIMEOUT:print_ticks}, timeout=5)
219 run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={TIMEOUT:print_ticks}, timeout=5)
220
220
221 The 'events' argument should be a dictionary of patterns and responses.
221 The 'events' argument should be a dictionary of patterns and responses.
222 Whenever one of the patterns is seen in the command out run() will send the
222 Whenever one of the patterns is seen in the command out run() will send the
223 associated response string. Note that you should put newlines in your
223 associated response string. Note that you should put newlines in your
224 string if Enter is necessary. The responses may also contain callback
224 string if Enter is necessary. The responses may also contain callback
225 functions. Any callback is function that takes a dictionary as an argument.
225 functions. Any callback is function that takes a dictionary as an argument.
226 The dictionary contains all the locals from the run() function, so you can
226 The dictionary contains all the locals from the run() function, so you can
227 access the child spawn object or any other variable defined in run()
227 access the child spawn object or any other variable defined in run()
228 (event_count, child, and extra_args are the most useful). A callback may
228 (event_count, child, and extra_args are the most useful). A callback may
229 return True to stop the current run process otherwise run() continues until
229 return True to stop the current run process otherwise run() continues until
230 the next event. A callback may also return a string which will be sent to
230 the next event. A callback may also return a string which will be sent to
231 the child. 'extra_args' is not used by directly run(). It provides a way to
231 the child. 'extra_args' is not used by directly run(). It provides a way to
232 pass data to a callback function through run() through the locals
232 pass data to a callback function through run() through the locals
233 dictionary passed to a callback."""
233 dictionary passed to a callback."""
234
234
235 if timeout == -1:
235 if timeout == -1:
236 child = spawn(command, maxread=2000, logfile=logfile, cwd=cwd, env=env,
236 child = spawn(command, maxread=2000, logfile=logfile, cwd=cwd, env=env,
237 encoding=encoding)
237 encoding=encoding)
238 else:
238 else:
239 child = spawn(command, timeout=timeout, maxread=2000, logfile=logfile,
239 child = spawn(command, timeout=timeout, maxread=2000, logfile=logfile,
240 cwd=cwd, env=env, encoding=encoding)
240 cwd=cwd, env=env, encoding=encoding)
241 if events is not None:
241 if events is not None:
242 patterns = events.keys()
242 patterns = events.keys()
243 responses = events.values()
243 responses = events.values()
244 else:
244 else:
245 patterns=None # We assume that EOF or TIMEOUT will save us.
245 patterns=None # We assume that EOF or TIMEOUT will save us.
246 responses=None
246 responses=None
247 child_result_list = []
247 child_result_list = []
248 event_count = 0
248 event_count = 0
249 while 1:
249 while 1:
250 try:
250 try:
251 index = child.expect (patterns)
251 index = child.expect (patterns)
252 if isinstance(child.after, basestring):
252 if isinstance(child.after, basestring):
253 child_result_list.append(child.before + child.after)
253 child_result_list.append(child.before + child.after)
254 else: # child.after may have been a TIMEOUT or EOF, so don't cat those.
254 else: # child.after may have been a TIMEOUT or EOF, so don't cat those.
255 child_result_list.append(child.before)
255 child_result_list.append(child.before)
256 if isinstance(responses[index], basestring):
256 if isinstance(responses[index], basestring):
257 child.send(responses[index])
257 child.send(responses[index])
258 elif type(responses[index]) is types.FunctionType:
258 elif type(responses[index]) is types.FunctionType:
259 callback_result = responses[index](locals())
259 callback_result = responses[index](locals())
260 sys.stdout.flush()
260 sys.stdout.flush()
261 if isinstance(callback_result, basestring):
261 if isinstance(callback_result, basestring):
262 child.send(callback_result)
262 child.send(callback_result)
263 elif callback_result:
263 elif callback_result:
264 break
264 break
265 else:
265 else:
266 raise TypeError ('The callback must be a string or function type.')
266 raise TypeError ('The callback must be a string or function type.')
267 event_count = event_count + 1
267 event_count = event_count + 1
268 except TIMEOUT, e:
268 except TIMEOUT, e:
269 child_result_list.append(child.before)
269 child_result_list.append(child.before)
270 break
270 break
271 except EOF, e:
271 except EOF, e:
272 child_result_list.append(child.before)
272 child_result_list.append(child.before)
273 break
273 break
274 child_result = child._empty_buffer.join(child_result_list)
274 child_result = child._empty_buffer.join(child_result_list)
275 if withexitstatus:
275 if withexitstatus:
276 child.close()
276 child.close()
277 return (child_result, child.exitstatus)
277 return (child_result, child.exitstatus)
278 else:
278 else:
279 return child_result
279 return child_result
280
280
281 class spawnb(object):
281 class spawnb(object):
282 """Use this class to start and control child applications with a pure-bytes
282 """Use this class to start and control child applications with a pure-bytes
283 interface."""
283 interface."""
284
284
285 _buffer_type = bytes
285 _buffer_type = bytes
286 def _cast_buffer_type(self, s):
286 def _cast_buffer_type(self, s):
287 return _cast_bytes(s, self.encoding)
287 return _cast_bytes(s, self.encoding)
288 _empty_buffer = b''
288 _empty_buffer = b''
289 _pty_newline = b'\r\n'
289 _pty_newline = b'\r\n'
290
290
291 # Some code needs this to exist, but it's mainly for the spawn subclass.
291 # Some code needs this to exist, but it's mainly for the spawn subclass.
292 encoding = 'utf-8'
292 encoding = 'utf-8'
293
293
294 def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None,
294 def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None,
295 logfile=None, cwd=None, env=None):
295 logfile=None, cwd=None, env=None):
296
296
297 """This is the constructor. The command parameter may be a string that
297 """This is the constructor. The command parameter may be a string that
298 includes a command and any arguments to the command. For example::
298 includes a command and any arguments to the command. For example::
299
299
300 child = pexpect.spawn ('/usr/bin/ftp')
300 child = pexpect.spawn ('/usr/bin/ftp')
301 child = pexpect.spawn ('/usr/bin/ssh user@example.com')
301 child = pexpect.spawn ('/usr/bin/ssh user@example.com')
302 child = pexpect.spawn ('ls -latr /tmp')
302 child = pexpect.spawn ('ls -latr /tmp')
303
303
304 You may also construct it with a list of arguments like so::
304 You may also construct it with a list of arguments like so::
305
305
306 child = pexpect.spawn ('/usr/bin/ftp', [])
306 child = pexpect.spawn ('/usr/bin/ftp', [])
307 child = pexpect.spawn ('/usr/bin/ssh', ['user@example.com'])
307 child = pexpect.spawn ('/usr/bin/ssh', ['user@example.com'])
308 child = pexpect.spawn ('ls', ['-latr', '/tmp'])
308 child = pexpect.spawn ('ls', ['-latr', '/tmp'])
309
309
310 After this the child application will be created and will be ready to
310 After this the child application will be created and will be ready to
311 talk to. For normal use, see expect() and send() and sendline().
311 talk to. For normal use, see expect() and send() and sendline().
312
312
313 Remember that Pexpect does NOT interpret shell meta characters such as
313 Remember that Pexpect does NOT interpret shell meta characters such as
314 redirect, pipe, or wild cards (>, |, or *). This is a common mistake.
314 redirect, pipe, or wild cards (>, |, or *). This is a common mistake.
315 If you want to run a command and pipe it through another command then
315 If you want to run a command and pipe it through another command then
316 you must also start a shell. For example::
316 you must also start a shell. For example::
317
317
318 child = pexpect.spawn('/bin/bash -c "ls -l | grep LOG > log_list.txt"')
318 child = pexpect.spawn('/bin/bash -c "ls -l | grep LOG > log_list.txt"')
319 child.expect(pexpect.EOF)
319 child.expect(pexpect.EOF)
320
320
321 The second form of spawn (where you pass a list of arguments) is useful
321 The second form of spawn (where you pass a list of arguments) is useful
322 in situations where you wish to spawn a command and pass it its own
322 in situations where you wish to spawn a command and pass it its own
323 argument list. This can make syntax more clear. For example, the
323 argument list. This can make syntax more clear. For example, the
324 following is equivalent to the previous example::
324 following is equivalent to the previous example::
325
325
326 shell_cmd = 'ls -l | grep LOG > log_list.txt'
326 shell_cmd = 'ls -l | grep LOG > log_list.txt'
327 child = pexpect.spawn('/bin/bash', ['-c', shell_cmd])
327 child = pexpect.spawn('/bin/bash', ['-c', shell_cmd])
328 child.expect(pexpect.EOF)
328 child.expect(pexpect.EOF)
329
329
330 The maxread attribute sets the read buffer size. This is maximum number
330 The maxread attribute sets the read buffer size. This is maximum number
331 of bytes that Pexpect will try to read from a TTY at one time. Setting
331 of bytes that Pexpect will try to read from a TTY at one time. Setting
332 the maxread size to 1 will turn off buffering. Setting the maxread
332 the maxread size to 1 will turn off buffering. Setting the maxread
333 value higher may help performance in cases where large amounts of
333 value higher may help performance in cases where large amounts of
334 output are read back from the child. This feature is useful in
334 output are read back from the child. This feature is useful in
335 conjunction with searchwindowsize.
335 conjunction with searchwindowsize.
336
336
337 The searchwindowsize attribute sets the how far back in the incomming
337 The searchwindowsize attribute sets the how far back in the incomming
338 seach buffer Pexpect will search for pattern matches. Every time
338 seach buffer Pexpect will search for pattern matches. Every time
339 Pexpect reads some data from the child it will append the data to the
339 Pexpect reads some data from the child it will append the data to the
340 incomming buffer. The default is to search from the beginning of the
340 incomming buffer. The default is to search from the beginning of the
341 imcomming buffer each time new data is read from the child. But this is
341 imcomming buffer each time new data is read from the child. But this is
342 very inefficient if you are running a command that generates a large
342 very inefficient if you are running a command that generates a large
343 amount of data where you want to match The searchwindowsize does not
343 amount of data where you want to match The searchwindowsize does not
344 effect the size of the incomming data buffer. You will still have
344 effect the size of the incomming data buffer. You will still have
345 access to the full buffer after expect() returns.
345 access to the full buffer after expect() returns.
346
346
347 The logfile member turns on or off logging. All input and output will
347 The logfile member turns on or off logging. All input and output will
348 be copied to the given file object. Set logfile to None to stop
348 be copied to the given file object. Set logfile to None to stop
349 logging. This is the default. Set logfile to sys.stdout to echo
349 logging. This is the default. Set logfile to sys.stdout to echo
350 everything to standard output. The logfile is flushed after each write.
350 everything to standard output. The logfile is flushed after each write.
351
351
352 Example log input and output to a file::
352 Example log input and output to a file::
353
353
354 child = pexpect.spawn('some_command')
354 child = pexpect.spawn('some_command')
355 fout = file('mylog.txt','w')
355 fout = open('mylog.txt','w')
356 child.logfile = fout
356 child.logfile = fout
357
357
358 Example log to stdout::
358 Example log to stdout::
359
359
360 child = pexpect.spawn('some_command')
360 child = pexpect.spawn('some_command')
361 child.logfile = sys.stdout
361 child.logfile = sys.stdout
362
362
363 The logfile_read and logfile_send members can be used to separately log
363 The logfile_read and logfile_send members can be used to separately log
364 the input from the child and output sent to the child. Sometimes you
364 the input from the child and output sent to the child. Sometimes you
365 don't want to see everything you write to the child. You only want to
365 don't want to see everything you write to the child. You only want to
366 log what the child sends back. For example::
366 log what the child sends back. For example::
367
367
368 child = pexpect.spawn('some_command')
368 child = pexpect.spawn('some_command')
369 child.logfile_read = sys.stdout
369 child.logfile_read = sys.stdout
370
370
371 To separately log output sent to the child use logfile_send::
371 To separately log output sent to the child use logfile_send::
372
372
373 self.logfile_send = fout
373 self.logfile_send = fout
374
374
375 The delaybeforesend helps overcome a weird behavior that many users
375 The delaybeforesend helps overcome a weird behavior that many users
376 were experiencing. The typical problem was that a user would expect() a
376 were experiencing. The typical problem was that a user would expect() a
377 "Password:" prompt and then immediately call sendline() to send the
377 "Password:" prompt and then immediately call sendline() to send the
378 password. The user would then see that their password was echoed back
378 password. The user would then see that their password was echoed back
379 to them. Passwords don't normally echo. The problem is caused by the
379 to them. Passwords don't normally echo. The problem is caused by the
380 fact that most applications print out the "Password" prompt and then
380 fact that most applications print out the "Password" prompt and then
381 turn off stdin echo, but if you send your password before the
381 turn off stdin echo, but if you send your password before the
382 application turned off echo, then you get your password echoed.
382 application turned off echo, then you get your password echoed.
383 Normally this wouldn't be a problem when interacting with a human at a
383 Normally this wouldn't be a problem when interacting with a human at a
384 real keyboard. If you introduce a slight delay just before writing then
384 real keyboard. If you introduce a slight delay just before writing then
385 this seems to clear up the problem. This was such a common problem for
385 this seems to clear up the problem. This was such a common problem for
386 many users that I decided that the default pexpect behavior should be
386 many users that I decided that the default pexpect behavior should be
387 to sleep just before writing to the child application. 1/20th of a
387 to sleep just before writing to the child application. 1/20th of a
388 second (50 ms) seems to be enough to clear up the problem. You can set
388 second (50 ms) seems to be enough to clear up the problem. You can set
389 delaybeforesend to 0 to return to the old behavior. Most Linux machines
389 delaybeforesend to 0 to return to the old behavior. Most Linux machines
390 don't like this to be below 0.03. I don't know why.
390 don't like this to be below 0.03. I don't know why.
391
391
392 Note that spawn is clever about finding commands on your path.
392 Note that spawn is clever about finding commands on your path.
393 It uses the same logic that "which" uses to find executables.
393 It uses the same logic that "which" uses to find executables.
394
394
395 If you wish to get the exit status of the child you must call the
395 If you wish to get the exit status of the child you must call the
396 close() method. The exit or signal status of the child will be stored
396 close() method. The exit or signal status of the child will be stored
397 in self.exitstatus or self.signalstatus. If the child exited normally
397 in self.exitstatus or self.signalstatus. If the child exited normally
398 then exitstatus will store the exit return code and signalstatus will
398 then exitstatus will store the exit return code and signalstatus will
399 be None. If the child was terminated abnormally with a signal then
399 be None. If the child was terminated abnormally with a signal then
400 signalstatus will store the signal value and exitstatus will be None.
400 signalstatus will store the signal value and exitstatus will be None.
401 If you need more detail you can also read the self.status member which
401 If you need more detail you can also read the self.status member which
402 stores the status returned by os.waitpid. You can interpret this using
402 stores the status returned by os.waitpid. You can interpret this using
403 os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG. """
403 os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG. """
404
404
405 self.STDIN_FILENO = pty.STDIN_FILENO
405 self.STDIN_FILENO = pty.STDIN_FILENO
406 self.STDOUT_FILENO = pty.STDOUT_FILENO
406 self.STDOUT_FILENO = pty.STDOUT_FILENO
407 self.STDERR_FILENO = pty.STDERR_FILENO
407 self.STDERR_FILENO = pty.STDERR_FILENO
408 self.stdin = sys.stdin
408 self.stdin = sys.stdin
409 self.stdout = sys.stdout
409 self.stdout = sys.stdout
410 self.stderr = sys.stderr
410 self.stderr = sys.stderr
411
411
412 self.searcher = None
412 self.searcher = None
413 self.ignorecase = False
413 self.ignorecase = False
414 self.before = None
414 self.before = None
415 self.after = None
415 self.after = None
416 self.match = None
416 self.match = None
417 self.match_index = None
417 self.match_index = None
418 self.terminated = True
418 self.terminated = True
419 self.exitstatus = None
419 self.exitstatus = None
420 self.signalstatus = None
420 self.signalstatus = None
421 self.status = None # status returned by os.waitpid
421 self.status = None # status returned by os.waitpid
422 self.flag_eof = False
422 self.flag_eof = False
423 self.pid = None
423 self.pid = None
424 self.child_fd = -1 # initially closed
424 self.child_fd = -1 # initially closed
425 self.timeout = timeout
425 self.timeout = timeout
426 self.delimiter = EOF
426 self.delimiter = EOF
427 self.logfile = logfile
427 self.logfile = logfile
428 self.logfile_read = None # input from child (read_nonblocking)
428 self.logfile_read = None # input from child (read_nonblocking)
429 self.logfile_send = None # output to send (send, sendline)
429 self.logfile_send = None # output to send (send, sendline)
430 self.maxread = maxread # max bytes to read at one time into buffer
430 self.maxread = maxread # max bytes to read at one time into buffer
431 self.buffer = self._empty_buffer # This is the read buffer. See maxread.
431 self.buffer = self._empty_buffer # This is the read buffer. See maxread.
432 self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched.
432 self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched.
433 # Most Linux machines don't like delaybeforesend to be below 0.03 (30 ms).
433 # Most Linux machines don't like delaybeforesend to be below 0.03 (30 ms).
434 self.delaybeforesend = 0.05 # Sets sleep time used just before sending data to child. Time in seconds.
434 self.delaybeforesend = 0.05 # Sets sleep time used just before sending data to child. Time in seconds.
435 self.delayafterclose = 0.1 # Sets delay in close() method to allow kernel time to update process status. Time in seconds.
435 self.delayafterclose = 0.1 # Sets delay in close() method to allow kernel time to update process status. Time in seconds.
436 self.delayafterterminate = 0.1 # Sets delay in terminate() method to allow kernel time to update process status. Time in seconds.
436 self.delayafterterminate = 0.1 # Sets delay in terminate() method to allow kernel time to update process status. Time in seconds.
437 self.softspace = False # File-like object.
437 self.softspace = False # File-like object.
438 self.name = '<' + repr(self) + '>' # File-like object.
438 self.name = '<' + repr(self) + '>' # File-like object.
439 self.closed = True # File-like object.
439 self.closed = True # File-like object.
440 self.cwd = cwd
440 self.cwd = cwd
441 self.env = env
441 self.env = env
442 self.__irix_hack = (sys.platform.lower().find('irix')>=0) # This flags if we are running on irix
442 self.__irix_hack = (sys.platform.lower().find('irix')>=0) # This flags if we are running on irix
443 # Solaris uses internal __fork_pty(). All others use pty.fork().
443 # Solaris uses internal __fork_pty(). All others use pty.fork().
444 if 'solaris' in sys.platform.lower() or 'sunos5' in sys.platform.lower():
444 if 'solaris' in sys.platform.lower() or 'sunos5' in sys.platform.lower():
445 self.use_native_pty_fork = False
445 self.use_native_pty_fork = False
446 else:
446 else:
447 self.use_native_pty_fork = True
447 self.use_native_pty_fork = True
448
448
449
449
450 # allow dummy instances for subclasses that may not use command or args.
450 # allow dummy instances for subclasses that may not use command or args.
451 if command is None:
451 if command is None:
452 self.command = None
452 self.command = None
453 self.args = None
453 self.args = None
454 self.name = '<pexpect factory incomplete>'
454 self.name = '<pexpect factory incomplete>'
455 else:
455 else:
456 self._spawn (command, args)
456 self._spawn (command, args)
457
457
458 def __del__(self):
458 def __del__(self):
459
459
460 """This makes sure that no system resources are left open. Python only
460 """This makes sure that no system resources are left open. Python only
461 garbage collects Python objects. OS file descriptors are not Python
461 garbage collects Python objects. OS file descriptors are not Python
462 objects, so they must be handled explicitly. If the child file
462 objects, so they must be handled explicitly. If the child file
463 descriptor was opened outside of this class (passed to the constructor)
463 descriptor was opened outside of this class (passed to the constructor)
464 then this does not close it. """
464 then this does not close it. """
465
465
466 if not self.closed:
466 if not self.closed:
467 # It is possible for __del__ methods to execute during the
467 # It is possible for __del__ methods to execute during the
468 # teardown of the Python VM itself. Thus self.close() may
468 # teardown of the Python VM itself. Thus self.close() may
469 # trigger an exception because os.close may be None.
469 # trigger an exception because os.close may be None.
470 # -- Fernando Perez
470 # -- Fernando Perez
471 try:
471 try:
472 self.close()
472 self.close()
473 except:
473 except:
474 pass
474 pass
475
475
476 def __str__(self):
476 def __str__(self):
477
477
478 """This returns a human-readable string that represents the state of
478 """This returns a human-readable string that represents the state of
479 the object. """
479 the object. """
480
480
481 s = []
481 s = []
482 s.append(repr(self))
482 s.append(repr(self))
483 s.append('version: ' + __version__)
483 s.append('version: ' + __version__)
484 s.append('command: ' + str(self.command))
484 s.append('command: ' + str(self.command))
485 s.append('args: ' + str(self.args))
485 s.append('args: ' + str(self.args))
486 s.append('searcher: ' + str(self.searcher))
486 s.append('searcher: ' + str(self.searcher))
487 s.append('buffer (last 100 chars): ' + str(self.buffer)[-100:])
487 s.append('buffer (last 100 chars): ' + str(self.buffer)[-100:])
488 s.append('before (last 100 chars): ' + str(self.before)[-100:])
488 s.append('before (last 100 chars): ' + str(self.before)[-100:])
489 s.append('after: ' + str(self.after))
489 s.append('after: ' + str(self.after))
490 s.append('match: ' + str(self.match))
490 s.append('match: ' + str(self.match))
491 s.append('match_index: ' + str(self.match_index))
491 s.append('match_index: ' + str(self.match_index))
492 s.append('exitstatus: ' + str(self.exitstatus))
492 s.append('exitstatus: ' + str(self.exitstatus))
493 s.append('flag_eof: ' + str(self.flag_eof))
493 s.append('flag_eof: ' + str(self.flag_eof))
494 s.append('pid: ' + str(self.pid))
494 s.append('pid: ' + str(self.pid))
495 s.append('child_fd: ' + str(self.child_fd))
495 s.append('child_fd: ' + str(self.child_fd))
496 s.append('closed: ' + str(self.closed))
496 s.append('closed: ' + str(self.closed))
497 s.append('timeout: ' + str(self.timeout))
497 s.append('timeout: ' + str(self.timeout))
498 s.append('delimiter: ' + str(self.delimiter))
498 s.append('delimiter: ' + str(self.delimiter))
499 s.append('logfile: ' + str(self.logfile))
499 s.append('logfile: ' + str(self.logfile))
500 s.append('logfile_read: ' + str(self.logfile_read))
500 s.append('logfile_read: ' + str(self.logfile_read))
501 s.append('logfile_send: ' + str(self.logfile_send))
501 s.append('logfile_send: ' + str(self.logfile_send))
502 s.append('maxread: ' + str(self.maxread))
502 s.append('maxread: ' + str(self.maxread))
503 s.append('ignorecase: ' + str(self.ignorecase))
503 s.append('ignorecase: ' + str(self.ignorecase))
504 s.append('searchwindowsize: ' + str(self.searchwindowsize))
504 s.append('searchwindowsize: ' + str(self.searchwindowsize))
505 s.append('delaybeforesend: ' + str(self.delaybeforesend))
505 s.append('delaybeforesend: ' + str(self.delaybeforesend))
506 s.append('delayafterclose: ' + str(self.delayafterclose))
506 s.append('delayafterclose: ' + str(self.delayafterclose))
507 s.append('delayafterterminate: ' + str(self.delayafterterminate))
507 s.append('delayafterterminate: ' + str(self.delayafterterminate))
508 return '\n'.join(s)
508 return '\n'.join(s)
509
509
510 def _spawn(self,command,args=[]):
510 def _spawn(self,command,args=[]):
511
511
512 """This starts the given command in a child process. This does all the
512 """This starts the given command in a child process. This does all the
513 fork/exec type of stuff for a pty. This is called by __init__. If args
513 fork/exec type of stuff for a pty. This is called by __init__. If args
514 is empty then command will be parsed (split on spaces) and args will be
514 is empty then command will be parsed (split on spaces) and args will be
515 set to parsed arguments. """
515 set to parsed arguments. """
516
516
517 # The pid and child_fd of this object get set by this method.
517 # The pid and child_fd of this object get set by this method.
518 # Note that it is difficult for this method to fail.
518 # Note that it is difficult for this method to fail.
519 # You cannot detect if the child process cannot start.
519 # You cannot detect if the child process cannot start.
520 # So the only way you can tell if the child process started
520 # So the only way you can tell if the child process started
521 # or not is to try to read from the file descriptor. If you get
521 # or not is to try to read from the file descriptor. If you get
522 # EOF immediately then it means that the child is already dead.
522 # EOF immediately then it means that the child is already dead.
523 # That may not necessarily be bad because you may haved spawned a child
523 # That may not necessarily be bad because you may haved spawned a child
524 # that performs some task; creates no stdout output; and then dies.
524 # that performs some task; creates no stdout output; and then dies.
525
525
526 # If command is an int type then it may represent a file descriptor.
526 # If command is an int type then it may represent a file descriptor.
527 if type(command) == type(0):
527 if type(command) == type(0):
528 raise ExceptionPexpect ('Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.')
528 raise ExceptionPexpect ('Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.')
529
529
530 if type (args) != type([]):
530 if type (args) != type([]):
531 raise TypeError ('The argument, args, must be a list.')
531 raise TypeError ('The argument, args, must be a list.')
532
532
533 if args == []:
533 if args == []:
534 self.args = split_command_line(command)
534 self.args = split_command_line(command)
535 self.command = self.args[0]
535 self.command = self.args[0]
536 else:
536 else:
537 self.args = args[:] # work with a copy
537 self.args = args[:] # work with a copy
538 self.args.insert (0, command)
538 self.args.insert (0, command)
539 self.command = command
539 self.command = command
540
540
541 command_with_path = which(self.command)
541 command_with_path = which(self.command)
542 if command_with_path is None:
542 if command_with_path is None:
543 raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command)
543 raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command)
544 self.command = command_with_path
544 self.command = command_with_path
545 self.args[0] = self.command
545 self.args[0] = self.command
546
546
547 self.name = '<' + ' '.join (self.args) + '>'
547 self.name = '<' + ' '.join (self.args) + '>'
548
548
549 assert self.pid is None, 'The pid member should be None.'
549 assert self.pid is None, 'The pid member should be None.'
550 assert self.command is not None, 'The command member should not be None.'
550 assert self.command is not None, 'The command member should not be None.'
551
551
552 if self.use_native_pty_fork:
552 if self.use_native_pty_fork:
553 try:
553 try:
554 self.pid, self.child_fd = pty.fork()
554 self.pid, self.child_fd = pty.fork()
555 except OSError, e:
555 except OSError, e:
556 raise ExceptionPexpect('Error! pty.fork() failed: ' + str(e))
556 raise ExceptionPexpect('Error! pty.fork() failed: ' + str(e))
557 else: # Use internal __fork_pty
557 else: # Use internal __fork_pty
558 self.pid, self.child_fd = self.__fork_pty()
558 self.pid, self.child_fd = self.__fork_pty()
559
559
560 if self.pid == 0: # Child
560 if self.pid == 0: # Child
561 try:
561 try:
562 self.child_fd = sys.stdout.fileno() # used by setwinsize()
562 self.child_fd = sys.stdout.fileno() # used by setwinsize()
563 self.setwinsize(24, 80)
563 self.setwinsize(24, 80)
564 except:
564 except:
565 # Some platforms do not like setwinsize (Cygwin).
565 # Some platforms do not like setwinsize (Cygwin).
566 # This will cause problem when running applications that
566 # This will cause problem when running applications that
567 # are very picky about window size.
567 # are very picky about window size.
568 # This is a serious limitation, but not a show stopper.
568 # This is a serious limitation, but not a show stopper.
569 pass
569 pass
570 # Do not allow child to inherit open file descriptors from parent.
570 # Do not allow child to inherit open file descriptors from parent.
571 max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
571 max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
572 for i in range (3, max_fd):
572 for i in range (3, max_fd):
573 try:
573 try:
574 os.close (i)
574 os.close (i)
575 except OSError:
575 except OSError:
576 pass
576 pass
577
577
578 # I don't know why this works, but ignoring SIGHUP fixes a
578 # I don't know why this works, but ignoring SIGHUP fixes a
579 # problem when trying to start a Java daemon with sudo
579 # problem when trying to start a Java daemon with sudo
580 # (specifically, Tomcat).
580 # (specifically, Tomcat).
581 signal.signal(signal.SIGHUP, signal.SIG_IGN)
581 signal.signal(signal.SIGHUP, signal.SIG_IGN)
582
582
583 if self.cwd is not None:
583 if self.cwd is not None:
584 os.chdir(self.cwd)
584 os.chdir(self.cwd)
585 if self.env is None:
585 if self.env is None:
586 os.execv(self.command, self.args)
586 os.execv(self.command, self.args)
587 else:
587 else:
588 os.execvpe(self.command, self.args, self.env)
588 os.execvpe(self.command, self.args, self.env)
589
589
590 # Parent
590 # Parent
591 self.terminated = False
591 self.terminated = False
592 self.closed = False
592 self.closed = False
593
593
594 def __fork_pty(self):
594 def __fork_pty(self):
595
595
596 """This implements a substitute for the forkpty system call. This
596 """This implements a substitute for the forkpty system call. This
597 should be more portable than the pty.fork() function. Specifically,
597 should be more portable than the pty.fork() function. Specifically,
598 this should work on Solaris.
598 this should work on Solaris.
599
599
600 Modified 10.06.05 by Geoff Marshall: Implemented __fork_pty() method to
600 Modified 10.06.05 by Geoff Marshall: Implemented __fork_pty() method to
601 resolve the issue with Python's pty.fork() not supporting Solaris,
601 resolve the issue with Python's pty.fork() not supporting Solaris,
602 particularly ssh. Based on patch to posixmodule.c authored by Noah
602 particularly ssh. Based on patch to posixmodule.c authored by Noah
603 Spurrier::
603 Spurrier::
604
604
605 http://mail.python.org/pipermail/python-dev/2003-May/035281.html
605 http://mail.python.org/pipermail/python-dev/2003-May/035281.html
606
606
607 """
607 """
608
608
609 parent_fd, child_fd = os.openpty()
609 parent_fd, child_fd = os.openpty()
610 if parent_fd < 0 or child_fd < 0:
610 if parent_fd < 0 or child_fd < 0:
611 raise ExceptionPexpect, "Error! Could not open pty with os.openpty()."
611 raise ExceptionPexpect, "Error! Could not open pty with os.openpty()."
612
612
613 pid = os.fork()
613 pid = os.fork()
614 if pid < 0:
614 if pid < 0:
615 raise ExceptionPexpect, "Error! Failed os.fork()."
615 raise ExceptionPexpect, "Error! Failed os.fork()."
616 elif pid == 0:
616 elif pid == 0:
617 # Child.
617 # Child.
618 os.close(parent_fd)
618 os.close(parent_fd)
619 self.__pty_make_controlling_tty(child_fd)
619 self.__pty_make_controlling_tty(child_fd)
620
620
621 os.dup2(child_fd, 0)
621 os.dup2(child_fd, 0)
622 os.dup2(child_fd, 1)
622 os.dup2(child_fd, 1)
623 os.dup2(child_fd, 2)
623 os.dup2(child_fd, 2)
624
624
625 if child_fd > 2:
625 if child_fd > 2:
626 os.close(child_fd)
626 os.close(child_fd)
627 else:
627 else:
628 # Parent.
628 # Parent.
629 os.close(child_fd)
629 os.close(child_fd)
630
630
631 return pid, parent_fd
631 return pid, parent_fd
632
632
633 def __pty_make_controlling_tty(self, tty_fd):
633 def __pty_make_controlling_tty(self, tty_fd):
634
634
635 """This makes the pseudo-terminal the controlling tty. This should be
635 """This makes the pseudo-terminal the controlling tty. This should be
636 more portable than the pty.fork() function. Specifically, this should
636 more portable than the pty.fork() function. Specifically, this should
637 work on Solaris. """
637 work on Solaris. """
638
638
639 child_name = os.ttyname(tty_fd)
639 child_name = os.ttyname(tty_fd)
640
640
641 # Disconnect from controlling tty. Harmless if not already connected.
641 # Disconnect from controlling tty. Harmless if not already connected.
642 try:
642 try:
643 fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
643 fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
644 if fd >= 0:
644 if fd >= 0:
645 os.close(fd)
645 os.close(fd)
646 except:
646 except:
647 # Already disconnected. This happens if running inside cron.
647 # Already disconnected. This happens if running inside cron.
648 pass
648 pass
649
649
650 os.setsid()
650 os.setsid()
651
651
652 # Verify we are disconnected from controlling tty
652 # Verify we are disconnected from controlling tty
653 # by attempting to open it again.
653 # by attempting to open it again.
654 try:
654 try:
655 fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
655 fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
656 if fd >= 0:
656 if fd >= 0:
657 os.close(fd)
657 os.close(fd)
658 raise ExceptionPexpect, "Error! Failed to disconnect from controlling tty. It is still possible to open /dev/tty."
658 raise ExceptionPexpect, "Error! Failed to disconnect from controlling tty. It is still possible to open /dev/tty."
659 except:
659 except:
660 # Good! We are disconnected from a controlling tty.
660 # Good! We are disconnected from a controlling tty.
661 pass
661 pass
662
662
663 # Verify we can open child pty.
663 # Verify we can open child pty.
664 fd = os.open(child_name, os.O_RDWR);
664 fd = os.open(child_name, os.O_RDWR);
665 if fd < 0:
665 if fd < 0:
666 raise ExceptionPexpect, "Error! Could not open child pty, " + child_name
666 raise ExceptionPexpect, "Error! Could not open child pty, " + child_name
667 else:
667 else:
668 os.close(fd)
668 os.close(fd)
669
669
670 # Verify we now have a controlling tty.
670 # Verify we now have a controlling tty.
671 fd = os.open("/dev/tty", os.O_WRONLY)
671 fd = os.open("/dev/tty", os.O_WRONLY)
672 if fd < 0:
672 if fd < 0:
673 raise ExceptionPexpect, "Error! Could not open controlling tty, /dev/tty"
673 raise ExceptionPexpect, "Error! Could not open controlling tty, /dev/tty"
674 else:
674 else:
675 os.close(fd)
675 os.close(fd)
676
676
677 def fileno (self): # File-like object.
677 def fileno (self): # File-like object.
678
678
679 """This returns the file descriptor of the pty for the child.
679 """This returns the file descriptor of the pty for the child.
680 """
680 """
681
681
682 return self.child_fd
682 return self.child_fd
683
683
684 def close (self, force=True): # File-like object.
684 def close (self, force=True): # File-like object.
685
685
686 """This closes the connection with the child application. Note that
686 """This closes the connection with the child application. Note that
687 calling close() more than once is valid. This emulates standard Python
687 calling close() more than once is valid. This emulates standard Python
688 behavior with files. Set force to True if you want to make sure that
688 behavior with files. Set force to True if you want to make sure that
689 the child is terminated (SIGKILL is sent if the child ignores SIGHUP
689 the child is terminated (SIGKILL is sent if the child ignores SIGHUP
690 and SIGINT). """
690 and SIGINT). """
691
691
692 if not self.closed:
692 if not self.closed:
693 self.flush()
693 self.flush()
694 os.close (self.child_fd)
694 os.close (self.child_fd)
695 time.sleep(self.delayafterclose) # Give kernel time to update process status.
695 time.sleep(self.delayafterclose) # Give kernel time to update process status.
696 if self.isalive():
696 if self.isalive():
697 if not self.terminate(force):
697 if not self.terminate(force):
698 raise ExceptionPexpect ('close() could not terminate the child using terminate()')
698 raise ExceptionPexpect ('close() could not terminate the child using terminate()')
699 self.child_fd = -1
699 self.child_fd = -1
700 self.closed = True
700 self.closed = True
701 #self.pid = None
701 #self.pid = None
702
702
703 def flush (self): # File-like object.
703 def flush (self): # File-like object.
704
704
705 """This does nothing. It is here to support the interface for a
705 """This does nothing. It is here to support the interface for a
706 File-like object. """
706 File-like object. """
707
707
708 pass
708 pass
709
709
710 def isatty (self): # File-like object.
710 def isatty (self): # File-like object.
711
711
712 """This returns True if the file descriptor is open and connected to a
712 """This returns True if the file descriptor is open and connected to a
713 tty(-like) device, else False. """
713 tty(-like) device, else False. """
714
714
715 return os.isatty(self.child_fd)
715 return os.isatty(self.child_fd)
716
716
717 def waitnoecho (self, timeout=-1):
717 def waitnoecho (self, timeout=-1):
718
718
719 """This waits until the terminal ECHO flag is set False. This returns
719 """This waits until the terminal ECHO flag is set False. This returns
720 True if the echo mode is off. This returns False if the ECHO flag was
720 True if the echo mode is off. This returns False if the ECHO flag was
721 not set False before the timeout. This can be used to detect when the
721 not set False before the timeout. This can be used to detect when the
722 child is waiting for a password. Usually a child application will turn
722 child is waiting for a password. Usually a child application will turn
723 off echo mode when it is waiting for the user to enter a password. For
723 off echo mode when it is waiting for the user to enter a password. For
724 example, instead of expecting the "password:" prompt you can wait for
724 example, instead of expecting the "password:" prompt you can wait for
725 the child to set ECHO off::
725 the child to set ECHO off::
726
726
727 p = pexpect.spawn ('ssh user@example.com')
727 p = pexpect.spawn ('ssh user@example.com')
728 p.waitnoecho()
728 p.waitnoecho()
729 p.sendline(mypassword)
729 p.sendline(mypassword)
730
730
731 If timeout==-1 then this method will use the value in self.timeout.
731 If timeout==-1 then this method will use the value in self.timeout.
732 If timeout==None then this method to block until ECHO flag is False.
732 If timeout==None then this method to block until ECHO flag is False.
733 """
733 """
734
734
735 if timeout == -1:
735 if timeout == -1:
736 timeout = self.timeout
736 timeout = self.timeout
737 if timeout is not None:
737 if timeout is not None:
738 end_time = time.time() + timeout
738 end_time = time.time() + timeout
739 while True:
739 while True:
740 if not self.getecho():
740 if not self.getecho():
741 return True
741 return True
742 if timeout < 0 and timeout is not None:
742 if timeout < 0 and timeout is not None:
743 return False
743 return False
744 if timeout is not None:
744 if timeout is not None:
745 timeout = end_time - time.time()
745 timeout = end_time - time.time()
746 time.sleep(0.1)
746 time.sleep(0.1)
747
747
748 def getecho (self):
748 def getecho (self):
749
749
750 """This returns the terminal echo mode. This returns True if echo is
750 """This returns the terminal echo mode. This returns True if echo is
751 on or False if echo is off. Child applications that are expecting you
751 on or False if echo is off. Child applications that are expecting you
752 to enter a password often set ECHO False. See waitnoecho(). """
752 to enter a password often set ECHO False. See waitnoecho(). """
753
753
754 attr = termios.tcgetattr(self.child_fd)
754 attr = termios.tcgetattr(self.child_fd)
755 if attr[3] & termios.ECHO:
755 if attr[3] & termios.ECHO:
756 return True
756 return True
757 return False
757 return False
758
758
759 def setecho (self, state):
759 def setecho (self, state):
760
760
761 """This sets the terminal echo mode on or off. Note that anything the
761 """This sets the terminal echo mode on or off. Note that anything the
762 child sent before the echo will be lost, so you should be sure that
762 child sent before the echo will be lost, so you should be sure that
763 your input buffer is empty before you call setecho(). For example, the
763 your input buffer is empty before you call setecho(). For example, the
764 following will work as expected::
764 following will work as expected::
765
765
766 p = pexpect.spawn('cat')
766 p = pexpect.spawn('cat')
767 p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
767 p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
768 p.expect (['1234'])
768 p.expect (['1234'])
769 p.expect (['1234'])
769 p.expect (['1234'])
770 p.setecho(False) # Turn off tty echo
770 p.setecho(False) # Turn off tty echo
771 p.sendline ('abcd') # We will set this only once (echoed by cat).
771 p.sendline ('abcd') # We will set this only once (echoed by cat).
772 p.sendline ('wxyz') # We will set this only once (echoed by cat)
772 p.sendline ('wxyz') # We will set this only once (echoed by cat)
773 p.expect (['abcd'])
773 p.expect (['abcd'])
774 p.expect (['wxyz'])
774 p.expect (['wxyz'])
775
775
776 The following WILL NOT WORK because the lines sent before the setecho
776 The following WILL NOT WORK because the lines sent before the setecho
777 will be lost::
777 will be lost::
778
778
779 p = pexpect.spawn('cat')
779 p = pexpect.spawn('cat')
780 p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
780 p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
781 p.setecho(False) # Turn off tty echo
781 p.setecho(False) # Turn off tty echo
782 p.sendline ('abcd') # We will set this only once (echoed by cat).
782 p.sendline ('abcd') # We will set this only once (echoed by cat).
783 p.sendline ('wxyz') # We will set this only once (echoed by cat)
783 p.sendline ('wxyz') # We will set this only once (echoed by cat)
784 p.expect (['1234'])
784 p.expect (['1234'])
785 p.expect (['1234'])
785 p.expect (['1234'])
786 p.expect (['abcd'])
786 p.expect (['abcd'])
787 p.expect (['wxyz'])
787 p.expect (['wxyz'])
788 """
788 """
789
789
790 self.child_fd
790 self.child_fd
791 attr = termios.tcgetattr(self.child_fd)
791 attr = termios.tcgetattr(self.child_fd)
792 if state:
792 if state:
793 attr[3] = attr[3] | termios.ECHO
793 attr[3] = attr[3] | termios.ECHO
794 else:
794 else:
795 attr[3] = attr[3] & ~termios.ECHO
795 attr[3] = attr[3] & ~termios.ECHO
796 # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent
796 # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent
797 # and blocked on some platforms. TCSADRAIN is probably ideal if it worked.
797 # and blocked on some platforms. TCSADRAIN is probably ideal if it worked.
798 termios.tcsetattr(self.child_fd, termios.TCSANOW, attr)
798 termios.tcsetattr(self.child_fd, termios.TCSANOW, attr)
799
799
800 def read_nonblocking (self, size = 1, timeout = -1):
800 def read_nonblocking (self, size = 1, timeout = -1):
801
801
802 """This reads at most size bytes from the child application. It
802 """This reads at most size bytes from the child application. It
803 includes a timeout. If the read does not complete within the timeout
803 includes a timeout. If the read does not complete within the timeout
804 period then a TIMEOUT exception is raised. If the end of file is read
804 period then a TIMEOUT exception is raised. If the end of file is read
805 then an EOF exception will be raised. If a log file was set using
805 then an EOF exception will be raised. If a log file was set using
806 setlog() then all data will also be written to the log file.
806 setlog() then all data will also be written to the log file.
807
807
808 If timeout is None then the read may block indefinitely. If timeout is -1
808 If timeout is None then the read may block indefinitely. If timeout is -1
809 then the self.timeout value is used. If timeout is 0 then the child is
809 then the self.timeout value is used. If timeout is 0 then the child is
810 polled and if there was no data immediately ready then this will raise
810 polled and if there was no data immediately ready then this will raise
811 a TIMEOUT exception.
811 a TIMEOUT exception.
812
812
813 The timeout refers only to the amount of time to read at least one
813 The timeout refers only to the amount of time to read at least one
814 character. This is not effected by the 'size' parameter, so if you call
814 character. This is not effected by the 'size' parameter, so if you call
815 read_nonblocking(size=100, timeout=30) and only one character is
815 read_nonblocking(size=100, timeout=30) and only one character is
816 available right away then one character will be returned immediately.
816 available right away then one character will be returned immediately.
817 It will not wait for 30 seconds for another 99 characters to come in.
817 It will not wait for 30 seconds for another 99 characters to come in.
818
818
819 This is a wrapper around os.read(). It uses select.select() to
819 This is a wrapper around os.read(). It uses select.select() to
820 implement the timeout. """
820 implement the timeout. """
821
821
822 if self.closed:
822 if self.closed:
823 raise ValueError ('I/O operation on closed file in read_nonblocking().')
823 raise ValueError ('I/O operation on closed file in read_nonblocking().')
824
824
825 if timeout == -1:
825 if timeout == -1:
826 timeout = self.timeout
826 timeout = self.timeout
827
827
828 # Note that some systems such as Solaris do not give an EOF when
828 # Note that some systems such as Solaris do not give an EOF when
829 # the child dies. In fact, you can still try to read
829 # the child dies. In fact, you can still try to read
830 # from the child_fd -- it will block forever or until TIMEOUT.
830 # from the child_fd -- it will block forever or until TIMEOUT.
831 # For this case, I test isalive() before doing any reading.
831 # For this case, I test isalive() before doing any reading.
832 # If isalive() is false, then I pretend that this is the same as EOF.
832 # If isalive() is false, then I pretend that this is the same as EOF.
833 if not self.isalive():
833 if not self.isalive():
834 r,w,e = self.__select([self.child_fd], [], [], 0) # timeout of 0 means "poll"
834 r,w,e = self.__select([self.child_fd], [], [], 0) # timeout of 0 means "poll"
835 if not r:
835 if not r:
836 self.flag_eof = True
836 self.flag_eof = True
837 raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.')
837 raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.')
838 elif self.__irix_hack:
838 elif self.__irix_hack:
839 # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive.
839 # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive.
840 # This adds a 2 second delay, but only when the child is terminated.
840 # This adds a 2 second delay, but only when the child is terminated.
841 r, w, e = self.__select([self.child_fd], [], [], 2)
841 r, w, e = self.__select([self.child_fd], [], [], 2)
842 if not r and not self.isalive():
842 if not r and not self.isalive():
843 self.flag_eof = True
843 self.flag_eof = True
844 raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.')
844 raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.')
845
845
846 r,w,e = self.__select([self.child_fd], [], [], timeout)
846 r,w,e = self.__select([self.child_fd], [], [], timeout)
847
847
848 if not r:
848 if not r:
849 if not self.isalive():
849 if not self.isalive():
850 # Some platforms, such as Irix, will claim that their processes are alive;
850 # Some platforms, such as Irix, will claim that their processes are alive;
851 # then timeout on the select; and then finally admit that they are not alive.
851 # then timeout on the select; and then finally admit that they are not alive.
852 self.flag_eof = True
852 self.flag_eof = True
853 raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.')
853 raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.')
854 else:
854 else:
855 raise TIMEOUT ('Timeout exceeded in read_nonblocking().')
855 raise TIMEOUT ('Timeout exceeded in read_nonblocking().')
856
856
857 if self.child_fd in r:
857 if self.child_fd in r:
858 try:
858 try:
859 s = os.read(self.child_fd, size)
859 s = os.read(self.child_fd, size)
860 except OSError, e: # Linux does this
860 except OSError, e: # Linux does this
861 self.flag_eof = True
861 self.flag_eof = True
862 raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.')
862 raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.')
863 if s == b'': # BSD style
863 if s == b'': # BSD style
864 self.flag_eof = True
864 self.flag_eof = True
865 raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.')
865 raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.')
866
866
867 s2 = self._cast_buffer_type(s)
867 s2 = self._cast_buffer_type(s)
868 if self.logfile is not None:
868 if self.logfile is not None:
869 self.logfile.write(s2)
869 self.logfile.write(s2)
870 self.logfile.flush()
870 self.logfile.flush()
871 if self.logfile_read is not None:
871 if self.logfile_read is not None:
872 self.logfile_read.write(s2)
872 self.logfile_read.write(s2)
873 self.logfile_read.flush()
873 self.logfile_read.flush()
874
874
875 return s
875 return s
876
876
877 raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().')
877 raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().')
878
878
879 def read (self, size = -1): # File-like object.
879 def read (self, size = -1): # File-like object.
880 """This reads at most "size" bytes from the file (less if the read hits
880 """This reads at most "size" bytes from the file (less if the read hits
881 EOF before obtaining size bytes). If the size argument is negative or
881 EOF before obtaining size bytes). If the size argument is negative or
882 omitted, read all data until EOF is reached. The bytes are returned as
882 omitted, read all data until EOF is reached. The bytes are returned as
883 a string object. An empty string is returned when EOF is encountered
883 a string object. An empty string is returned when EOF is encountered
884 immediately. """
884 immediately. """
885
885
886 if size == 0:
886 if size == 0:
887 return self._empty_buffer
887 return self._empty_buffer
888 if size < 0:
888 if size < 0:
889 self.expect (self.delimiter) # delimiter default is EOF
889 self.expect (self.delimiter) # delimiter default is EOF
890 return self.before
890 return self.before
891
891
892 # I could have done this more directly by not using expect(), but
892 # I could have done this more directly by not using expect(), but
893 # I deliberately decided to couple read() to expect() so that
893 # I deliberately decided to couple read() to expect() so that
894 # I would catch any bugs early and ensure consistant behavior.
894 # I would catch any bugs early and ensure consistant behavior.
895 # It's a little less efficient, but there is less for me to
895 # It's a little less efficient, but there is less for me to
896 # worry about if I have to later modify read() or expect().
896 # worry about if I have to later modify read() or expect().
897 # Note, it's OK if size==-1 in the regex. That just means it
897 # Note, it's OK if size==-1 in the regex. That just means it
898 # will never match anything in which case we stop only on EOF.
898 # will never match anything in which case we stop only on EOF.
899 if self._buffer_type is bytes:
899 if self._buffer_type is bytes:
900 pat = (u'.{%d}' % size).encode('ascii')
900 pat = (u'.{%d}' % size).encode('ascii')
901 else:
901 else:
902 pat = u'.{%d}' % size
902 pat = u'.{%d}' % size
903 cre = re.compile(pat, re.DOTALL)
903 cre = re.compile(pat, re.DOTALL)
904 index = self.expect ([cre, self.delimiter]) # delimiter default is EOF
904 index = self.expect ([cre, self.delimiter]) # delimiter default is EOF
905 if index == 0:
905 if index == 0:
906 return self.after ### self.before should be ''. Should I assert this?
906 return self.after ### self.before should be ''. Should I assert this?
907 return self.before
907 return self.before
908
908
909 def readline(self, size = -1):
909 def readline(self, size = -1):
910 """This reads and returns one entire line. A trailing newline is kept
910 """This reads and returns one entire line. A trailing newline is kept
911 in the string, but may be absent when a file ends with an incomplete
911 in the string, but may be absent when a file ends with an incomplete
912 line. Note: This readline() looks for a \\r\\n pair even on UNIX
912 line. Note: This readline() looks for a \\r\\n pair even on UNIX
913 because this is what the pseudo tty device returns. So contrary to what
913 because this is what the pseudo tty device returns. So contrary to what
914 you may expect you will receive the newline as \\r\\n. An empty string
914 you may expect you will receive the newline as \\r\\n. An empty string
915 is returned when EOF is hit immediately. Currently, the size argument is
915 is returned when EOF is hit immediately. Currently, the size argument is
916 mostly ignored, so this behavior is not standard for a file-like
916 mostly ignored, so this behavior is not standard for a file-like
917 object. If size is 0 then an empty string is returned. """
917 object. If size is 0 then an empty string is returned. """
918
918
919 if size == 0:
919 if size == 0:
920 return self._empty_buffer
920 return self._empty_buffer
921 index = self.expect ([self._pty_newline, self.delimiter]) # delimiter default is EOF
921 index = self.expect ([self._pty_newline, self.delimiter]) # delimiter default is EOF
922 if index == 0:
922 if index == 0:
923 return self.before + self._pty_newline
923 return self.before + self._pty_newline
924 return self.before
924 return self.before
925
925
926 def __iter__ (self): # File-like object.
926 def __iter__ (self): # File-like object.
927
927
928 """This is to support iterators over a file-like object.
928 """This is to support iterators over a file-like object.
929 """
929 """
930
930
931 return self
931 return self
932
932
933 def next (self): # File-like object.
933 def next (self): # File-like object.
934
934
935 """This is to support iterators over a file-like object.
935 """This is to support iterators over a file-like object.
936 """
936 """
937
937
938 result = self.readline()
938 result = self.readline()
939 if result == self._empty_buffer:
939 if result == self._empty_buffer:
940 raise StopIteration
940 raise StopIteration
941 return result
941 return result
942
942
943 def readlines (self, sizehint = -1): # File-like object.
943 def readlines (self, sizehint = -1): # File-like object.
944
944
945 """This reads until EOF using readline() and returns a list containing
945 """This reads until EOF using readline() and returns a list containing
946 the lines thus read. The optional "sizehint" argument is ignored. """
946 the lines thus read. The optional "sizehint" argument is ignored. """
947
947
948 lines = []
948 lines = []
949 while True:
949 while True:
950 line = self.readline()
950 line = self.readline()
951 if not line:
951 if not line:
952 break
952 break
953 lines.append(line)
953 lines.append(line)
954 return lines
954 return lines
955
955
956 def write(self, s): # File-like object.
956 def write(self, s): # File-like object.
957
957
958 """This is similar to send() except that there is no return value.
958 """This is similar to send() except that there is no return value.
959 """
959 """
960
960
961 self.send (s)
961 self.send (s)
962
962
963 def writelines (self, sequence): # File-like object.
963 def writelines (self, sequence): # File-like object.
964
964
965 """This calls write() for each element in the sequence. The sequence
965 """This calls write() for each element in the sequence. The sequence
966 can be any iterable object producing strings, typically a list of
966 can be any iterable object producing strings, typically a list of
967 strings. This does not add line separators There is no return value.
967 strings. This does not add line separators There is no return value.
968 """
968 """
969
969
970 for s in sequence:
970 for s in sequence:
971 self.write (s)
971 self.write (s)
972
972
973 def send(self, s):
973 def send(self, s):
974
974
975 """This sends a string to the child process. This returns the number of
975 """This sends a string to the child process. This returns the number of
976 bytes written. If a log file was set then the data is also written to
976 bytes written. If a log file was set then the data is also written to
977 the log. """
977 the log. """
978
978
979 time.sleep(self.delaybeforesend)
979 time.sleep(self.delaybeforesend)
980
980
981 s2 = self._cast_buffer_type(s)
981 s2 = self._cast_buffer_type(s)
982 if self.logfile is not None:
982 if self.logfile is not None:
983 self.logfile.write(s2)
983 self.logfile.write(s2)
984 self.logfile.flush()
984 self.logfile.flush()
985 if self.logfile_send is not None:
985 if self.logfile_send is not None:
986 self.logfile_send.write(s2)
986 self.logfile_send.write(s2)
987 self.logfile_send.flush()
987 self.logfile_send.flush()
988 c = os.write (self.child_fd, _cast_bytes(s, self.encoding))
988 c = os.write (self.child_fd, _cast_bytes(s, self.encoding))
989 return c
989 return c
990
990
991 def sendline(self, s=''):
991 def sendline(self, s=''):
992
992
993 """This is like send(), but it adds a line feed (os.linesep). This
993 """This is like send(), but it adds a line feed (os.linesep). This
994 returns the number of bytes written. """
994 returns the number of bytes written. """
995
995
996 n = self.send (s)
996 n = self.send (s)
997 n = n + self.send (os.linesep)
997 n = n + self.send (os.linesep)
998 return n
998 return n
999
999
1000 def sendcontrol(self, char):
1000 def sendcontrol(self, char):
1001
1001
1002 """This sends a control character to the child such as Ctrl-C or
1002 """This sends a control character to the child such as Ctrl-C or
1003 Ctrl-D. For example, to send a Ctrl-G (ASCII 7)::
1003 Ctrl-D. For example, to send a Ctrl-G (ASCII 7)::
1004
1004
1005 child.sendcontrol('g')
1005 child.sendcontrol('g')
1006
1006
1007 See also, sendintr() and sendeof().
1007 See also, sendintr() and sendeof().
1008 """
1008 """
1009
1009
1010 char = char.lower()
1010 char = char.lower()
1011 a = ord(char)
1011 a = ord(char)
1012 if a>=97 and a<=122:
1012 if a>=97 and a<=122:
1013 a = a - ord('a') + 1
1013 a = a - ord('a') + 1
1014 return self.send (chr(a))
1014 return self.send (chr(a))
1015 d = {'@':0, '`':0,
1015 d = {'@':0, '`':0,
1016 '[':27, '{':27,
1016 '[':27, '{':27,
1017 '\\':28, '|':28,
1017 '\\':28, '|':28,
1018 ']':29, '}': 29,
1018 ']':29, '}': 29,
1019 '^':30, '~':30,
1019 '^':30, '~':30,
1020 '_':31,
1020 '_':31,
1021 '?':127}
1021 '?':127}
1022 if char not in d:
1022 if char not in d:
1023 return 0
1023 return 0
1024 return self.send (chr(d[char]))
1024 return self.send (chr(d[char]))
1025
1025
1026 def sendeof(self):
1026 def sendeof(self):
1027
1027
1028 """This sends an EOF to the child. This sends a character which causes
1028 """This sends an EOF to the child. This sends a character which causes
1029 the pending parent output buffer to be sent to the waiting child
1029 the pending parent output buffer to be sent to the waiting child
1030 program without waiting for end-of-line. If it is the first character
1030 program without waiting for end-of-line. If it is the first character
1031 of the line, the read() in the user program returns 0, which signifies
1031 of the line, the read() in the user program returns 0, which signifies
1032 end-of-file. This means to work as expected a sendeof() has to be
1032 end-of-file. This means to work as expected a sendeof() has to be
1033 called at the beginning of a line. This method does not send a newline.
1033 called at the beginning of a line. This method does not send a newline.
1034 It is the responsibility of the caller to ensure the eof is sent at the
1034 It is the responsibility of the caller to ensure the eof is sent at the
1035 beginning of a line. """
1035 beginning of a line. """
1036
1036
1037 ### Hmmm... how do I send an EOF?
1037 ### Hmmm... how do I send an EOF?
1038 ###C if ((m = write(pty, *buf, p - *buf)) < 0)
1038 ###C if ((m = write(pty, *buf, p - *buf)) < 0)
1039 ###C return (errno == EWOULDBLOCK) ? n : -1;
1039 ###C return (errno == EWOULDBLOCK) ? n : -1;
1040 #fd = sys.stdin.fileno()
1040 #fd = sys.stdin.fileno()
1041 #old = termios.tcgetattr(fd) # remember current state
1041 #old = termios.tcgetattr(fd) # remember current state
1042 #attr = termios.tcgetattr(fd)
1042 #attr = termios.tcgetattr(fd)
1043 #attr[3] = attr[3] | termios.ICANON # ICANON must be set to recognize EOF
1043 #attr[3] = attr[3] | termios.ICANON # ICANON must be set to recognize EOF
1044 #try: # use try/finally to ensure state gets restored
1044 #try: # use try/finally to ensure state gets restored
1045 # termios.tcsetattr(fd, termios.TCSADRAIN, attr)
1045 # termios.tcsetattr(fd, termios.TCSADRAIN, attr)
1046 # if hasattr(termios, 'CEOF'):
1046 # if hasattr(termios, 'CEOF'):
1047 # os.write (self.child_fd, '%c' % termios.CEOF)
1047 # os.write (self.child_fd, '%c' % termios.CEOF)
1048 # else:
1048 # else:
1049 # # Silly platform does not define CEOF so assume CTRL-D
1049 # # Silly platform does not define CEOF so assume CTRL-D
1050 # os.write (self.child_fd, '%c' % 4)
1050 # os.write (self.child_fd, '%c' % 4)
1051 #finally: # restore state
1051 #finally: # restore state
1052 # termios.tcsetattr(fd, termios.TCSADRAIN, old)
1052 # termios.tcsetattr(fd, termios.TCSADRAIN, old)
1053 if hasattr(termios, 'VEOF'):
1053 if hasattr(termios, 'VEOF'):
1054 char = termios.tcgetattr(self.child_fd)[6][termios.VEOF]
1054 char = termios.tcgetattr(self.child_fd)[6][termios.VEOF]
1055 else:
1055 else:
1056 # platform does not define VEOF so assume CTRL-D
1056 # platform does not define VEOF so assume CTRL-D
1057 char = chr(4)
1057 char = chr(4)
1058 self.send(char)
1058 self.send(char)
1059
1059
1060 def sendintr(self):
1060 def sendintr(self):
1061
1061
1062 """This sends a SIGINT to the child. It does not require
1062 """This sends a SIGINT to the child. It does not require
1063 the SIGINT to be the first character on a line. """
1063 the SIGINT to be the first character on a line. """
1064
1064
1065 if hasattr(termios, 'VINTR'):
1065 if hasattr(termios, 'VINTR'):
1066 char = termios.tcgetattr(self.child_fd)[6][termios.VINTR]
1066 char = termios.tcgetattr(self.child_fd)[6][termios.VINTR]
1067 else:
1067 else:
1068 # platform does not define VINTR so assume CTRL-C
1068 # platform does not define VINTR so assume CTRL-C
1069 char = chr(3)
1069 char = chr(3)
1070 self.send (char)
1070 self.send (char)
1071
1071
1072 def eof (self):
1072 def eof (self):
1073
1073
1074 """This returns True if the EOF exception was ever raised.
1074 """This returns True if the EOF exception was ever raised.
1075 """
1075 """
1076
1076
1077 return self.flag_eof
1077 return self.flag_eof
1078
1078
1079 def terminate(self, force=False):
1079 def terminate(self, force=False):
1080
1080
1081 """This forces a child process to terminate. It starts nicely with
1081 """This forces a child process to terminate. It starts nicely with
1082 SIGHUP and SIGINT. If "force" is True then moves onto SIGKILL. This
1082 SIGHUP and SIGINT. If "force" is True then moves onto SIGKILL. This
1083 returns True if the child was terminated. This returns False if the
1083 returns True if the child was terminated. This returns False if the
1084 child could not be terminated. """
1084 child could not be terminated. """
1085
1085
1086 if not self.isalive():
1086 if not self.isalive():
1087 return True
1087 return True
1088 try:
1088 try:
1089 self.kill(signal.SIGHUP)
1089 self.kill(signal.SIGHUP)
1090 time.sleep(self.delayafterterminate)
1090 time.sleep(self.delayafterterminate)
1091 if not self.isalive():
1091 if not self.isalive():
1092 return True
1092 return True
1093 self.kill(signal.SIGCONT)
1093 self.kill(signal.SIGCONT)
1094 time.sleep(self.delayafterterminate)
1094 time.sleep(self.delayafterterminate)
1095 if not self.isalive():
1095 if not self.isalive():
1096 return True
1096 return True
1097 self.kill(signal.SIGINT)
1097 self.kill(signal.SIGINT)
1098 time.sleep(self.delayafterterminate)
1098 time.sleep(self.delayafterterminate)
1099 if not self.isalive():
1099 if not self.isalive():
1100 return True
1100 return True
1101 if force:
1101 if force:
1102 self.kill(signal.SIGKILL)
1102 self.kill(signal.SIGKILL)
1103 time.sleep(self.delayafterterminate)
1103 time.sleep(self.delayafterterminate)
1104 if not self.isalive():
1104 if not self.isalive():
1105 return True
1105 return True
1106 else:
1106 else:
1107 return False
1107 return False
1108 return False
1108 return False
1109 except OSError, e:
1109 except OSError, e:
1110 # I think there are kernel timing issues that sometimes cause
1110 # I think there are kernel timing issues that sometimes cause
1111 # this to happen. I think isalive() reports True, but the
1111 # this to happen. I think isalive() reports True, but the
1112 # process is dead to the kernel.
1112 # process is dead to the kernel.
1113 # Make one last attempt to see if the kernel is up to date.
1113 # Make one last attempt to see if the kernel is up to date.
1114 time.sleep(self.delayafterterminate)
1114 time.sleep(self.delayafterterminate)
1115 if not self.isalive():
1115 if not self.isalive():
1116 return True
1116 return True
1117 else:
1117 else:
1118 return False
1118 return False
1119
1119
1120 def wait(self):
1120 def wait(self):
1121
1121
1122 """This waits until the child exits. This is a blocking call. This will
1122 """This waits until the child exits. This is a blocking call. This will
1123 not read any data from the child, so this will block forever if the
1123 not read any data from the child, so this will block forever if the
1124 child has unread output and has terminated. In other words, the child
1124 child has unread output and has terminated. In other words, the child
1125 may have printed output then called exit(); but, technically, the child
1125 may have printed output then called exit(); but, technically, the child
1126 is still alive until its output is read. """
1126 is still alive until its output is read. """
1127
1127
1128 if self.isalive():
1128 if self.isalive():
1129 pid, status = os.waitpid(self.pid, 0)
1129 pid, status = os.waitpid(self.pid, 0)
1130 else:
1130 else:
1131 raise ExceptionPexpect ('Cannot wait for dead child process.')
1131 raise ExceptionPexpect ('Cannot wait for dead child process.')
1132 self.exitstatus = os.WEXITSTATUS(status)
1132 self.exitstatus = os.WEXITSTATUS(status)
1133 if os.WIFEXITED (status):
1133 if os.WIFEXITED (status):
1134 self.status = status
1134 self.status = status
1135 self.exitstatus = os.WEXITSTATUS(status)
1135 self.exitstatus = os.WEXITSTATUS(status)
1136 self.signalstatus = None
1136 self.signalstatus = None
1137 self.terminated = True
1137 self.terminated = True
1138 elif os.WIFSIGNALED (status):
1138 elif os.WIFSIGNALED (status):
1139 self.status = status
1139 self.status = status
1140 self.exitstatus = None
1140 self.exitstatus = None
1141 self.signalstatus = os.WTERMSIG(status)
1141 self.signalstatus = os.WTERMSIG(status)
1142 self.terminated = True
1142 self.terminated = True
1143 elif os.WIFSTOPPED (status):
1143 elif os.WIFSTOPPED (status):
1144 raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?')
1144 raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?')
1145 return self.exitstatus
1145 return self.exitstatus
1146
1146
1147 def isalive(self):
1147 def isalive(self):
1148
1148
1149 """This tests if the child process is running or not. This is
1149 """This tests if the child process is running or not. This is
1150 non-blocking. If the child was terminated then this will read the
1150 non-blocking. If the child was terminated then this will read the
1151 exitstatus or signalstatus of the child. This returns True if the child
1151 exitstatus or signalstatus of the child. This returns True if the child
1152 process appears to be running or False if not. It can take literally
1152 process appears to be running or False if not. It can take literally
1153 SECONDS for Solaris to return the right status. """
1153 SECONDS for Solaris to return the right status. """
1154
1154
1155 if self.terminated:
1155 if self.terminated:
1156 return False
1156 return False
1157
1157
1158 if self.flag_eof:
1158 if self.flag_eof:
1159 # This is for Linux, which requires the blocking form of waitpid to get
1159 # This is for Linux, which requires the blocking form of waitpid to get
1160 # status of a defunct process. This is super-lame. The flag_eof would have
1160 # status of a defunct process. This is super-lame. The flag_eof would have
1161 # been set in read_nonblocking(), so this should be safe.
1161 # been set in read_nonblocking(), so this should be safe.
1162 waitpid_options = 0
1162 waitpid_options = 0
1163 else:
1163 else:
1164 waitpid_options = os.WNOHANG
1164 waitpid_options = os.WNOHANG
1165
1165
1166 try:
1166 try:
1167 pid, status = os.waitpid(self.pid, waitpid_options)
1167 pid, status = os.waitpid(self.pid, waitpid_options)
1168 except OSError as e: # No child processes
1168 except OSError as e: # No child processes
1169 if e.errno == errno.ECHILD:
1169 if e.errno == errno.ECHILD:
1170 raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?')
1170 raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?')
1171 else:
1171 else:
1172 raise e
1172 raise e
1173
1173
1174 # I have to do this twice for Solaris. I can't even believe that I figured this out...
1174 # I have to do this twice for Solaris. I can't even believe that I figured this out...
1175 # If waitpid() returns 0 it means that no child process wishes to
1175 # If waitpid() returns 0 it means that no child process wishes to
1176 # report, and the value of status is undefined.
1176 # report, and the value of status is undefined.
1177 if pid == 0:
1177 if pid == 0:
1178 try:
1178 try:
1179 pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris!
1179 pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris!
1180 except OSError, e: # This should never happen...
1180 except OSError, e: # This should never happen...
1181 if e[0] == errno.ECHILD:
1181 if e[0] == errno.ECHILD:
1182 raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?')
1182 raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?')
1183 else:
1183 else:
1184 raise e
1184 raise e
1185
1185
1186 # If pid is still 0 after two calls to waitpid() then
1186 # If pid is still 0 after two calls to waitpid() then
1187 # the process really is alive. This seems to work on all platforms, except
1187 # the process really is alive. This seems to work on all platforms, except
1188 # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking
1188 # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking
1189 # take care of this situation (unfortunately, this requires waiting through the timeout).
1189 # take care of this situation (unfortunately, this requires waiting through the timeout).
1190 if pid == 0:
1190 if pid == 0:
1191 return True
1191 return True
1192
1192
1193 if pid == 0:
1193 if pid == 0:
1194 return True
1194 return True
1195
1195
1196 if os.WIFEXITED (status):
1196 if os.WIFEXITED (status):
1197 self.status = status
1197 self.status = status
1198 self.exitstatus = os.WEXITSTATUS(status)
1198 self.exitstatus = os.WEXITSTATUS(status)
1199 self.signalstatus = None
1199 self.signalstatus = None
1200 self.terminated = True
1200 self.terminated = True
1201 elif os.WIFSIGNALED (status):
1201 elif os.WIFSIGNALED (status):
1202 self.status = status
1202 self.status = status
1203 self.exitstatus = None
1203 self.exitstatus = None
1204 self.signalstatus = os.WTERMSIG(status)
1204 self.signalstatus = os.WTERMSIG(status)
1205 self.terminated = True
1205 self.terminated = True
1206 elif os.WIFSTOPPED (status):
1206 elif os.WIFSTOPPED (status):
1207 raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?')
1207 raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?')
1208 return False
1208 return False
1209
1209
1210 def kill(self, sig):
1210 def kill(self, sig):
1211
1211
1212 """This sends the given signal to the child application. In keeping
1212 """This sends the given signal to the child application. In keeping
1213 with UNIX tradition it has a misleading name. It does not necessarily
1213 with UNIX tradition it has a misleading name. It does not necessarily
1214 kill the child unless you send the right signal. """
1214 kill the child unless you send the right signal. """
1215
1215
1216 # Same as os.kill, but the pid is given for you.
1216 # Same as os.kill, but the pid is given for you.
1217 if self.isalive():
1217 if self.isalive():
1218 os.kill(self.pid, sig)
1218 os.kill(self.pid, sig)
1219
1219
1220 def compile_pattern_list(self, patterns):
1220 def compile_pattern_list(self, patterns):
1221
1221
1222 """This compiles a pattern-string or a list of pattern-strings.
1222 """This compiles a pattern-string or a list of pattern-strings.
1223 Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or a list of
1223 Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or a list of
1224 those. Patterns may also be None which results in an empty list (you
1224 those. Patterns may also be None which results in an empty list (you
1225 might do this if waiting for an EOF or TIMEOUT condition without
1225 might do this if waiting for an EOF or TIMEOUT condition without
1226 expecting any pattern).
1226 expecting any pattern).
1227
1227
1228 This is used by expect() when calling expect_list(). Thus expect() is
1228 This is used by expect() when calling expect_list(). Thus expect() is
1229 nothing more than::
1229 nothing more than::
1230
1230
1231 cpl = self.compile_pattern_list(pl)
1231 cpl = self.compile_pattern_list(pl)
1232 return self.expect_list(cpl, timeout)
1232 return self.expect_list(cpl, timeout)
1233
1233
1234 If you are using expect() within a loop it may be more
1234 If you are using expect() within a loop it may be more
1235 efficient to compile the patterns first and then call expect_list().
1235 efficient to compile the patterns first and then call expect_list().
1236 This avoid calls in a loop to compile_pattern_list()::
1236 This avoid calls in a loop to compile_pattern_list()::
1237
1237
1238 cpl = self.compile_pattern_list(my_pattern)
1238 cpl = self.compile_pattern_list(my_pattern)
1239 while some_condition:
1239 while some_condition:
1240 ...
1240 ...
1241 i = self.expect_list(clp, timeout)
1241 i = self.expect_list(clp, timeout)
1242 ...
1242 ...
1243 """
1243 """
1244
1244
1245 if patterns is None:
1245 if patterns is None:
1246 return []
1246 return []
1247 if not isinstance(patterns, list):
1247 if not isinstance(patterns, list):
1248 patterns = [patterns]
1248 patterns = [patterns]
1249
1249
1250 compile_flags = re.DOTALL # Allow dot to match \n
1250 compile_flags = re.DOTALL # Allow dot to match \n
1251 if self.ignorecase:
1251 if self.ignorecase:
1252 compile_flags = compile_flags | re.IGNORECASE
1252 compile_flags = compile_flags | re.IGNORECASE
1253 compiled_pattern_list = []
1253 compiled_pattern_list = []
1254 for p in patterns:
1254 for p in patterns:
1255 if isinstance(p, (bytes, unicode)):
1255 if isinstance(p, (bytes, unicode)):
1256 p = self._cast_buffer_type(p)
1256 p = self._cast_buffer_type(p)
1257 compiled_pattern_list.append(re.compile(p, compile_flags))
1257 compiled_pattern_list.append(re.compile(p, compile_flags))
1258 elif p is EOF:
1258 elif p is EOF:
1259 compiled_pattern_list.append(EOF)
1259 compiled_pattern_list.append(EOF)
1260 elif p is TIMEOUT:
1260 elif p is TIMEOUT:
1261 compiled_pattern_list.append(TIMEOUT)
1261 compiled_pattern_list.append(TIMEOUT)
1262 elif type(p) is re_type:
1262 elif type(p) is re_type:
1263 p = self._prepare_regex_pattern(p)
1263 p = self._prepare_regex_pattern(p)
1264 compiled_pattern_list.append(p)
1264 compiled_pattern_list.append(p)
1265 else:
1265 else:
1266 raise TypeError ('Argument must be one of StringTypes, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p)))
1266 raise TypeError ('Argument must be one of StringTypes, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p)))
1267
1267
1268 return compiled_pattern_list
1268 return compiled_pattern_list
1269
1269
1270 def _prepare_regex_pattern(self, p):
1270 def _prepare_regex_pattern(self, p):
1271 "Recompile unicode regexes as bytes regexes. Overridden in subclass."
1271 "Recompile unicode regexes as bytes regexes. Overridden in subclass."
1272 if isinstance(p.pattern, unicode):
1272 if isinstance(p.pattern, unicode):
1273 p = re.compile(p.pattern.encode('utf-8'), p.flags &~ re.UNICODE)
1273 p = re.compile(p.pattern.encode('utf-8'), p.flags &~ re.UNICODE)
1274 return p
1274 return p
1275
1275
1276 def expect(self, pattern, timeout = -1, searchwindowsize=-1):
1276 def expect(self, pattern, timeout = -1, searchwindowsize=-1):
1277
1277
1278 """This seeks through the stream until a pattern is matched. The
1278 """This seeks through the stream until a pattern is matched. The
1279 pattern is overloaded and may take several types. The pattern can be a
1279 pattern is overloaded and may take several types. The pattern can be a
1280 StringType, EOF, a compiled re, or a list of any of those types.
1280 StringType, EOF, a compiled re, or a list of any of those types.
1281 Strings will be compiled to re types. This returns the index into the
1281 Strings will be compiled to re types. This returns the index into the
1282 pattern list. If the pattern was not a list this returns index 0 on a
1282 pattern list. If the pattern was not a list this returns index 0 on a
1283 successful match. This may raise exceptions for EOF or TIMEOUT. To
1283 successful match. This may raise exceptions for EOF or TIMEOUT. To
1284 avoid the EOF or TIMEOUT exceptions add EOF or TIMEOUT to the pattern
1284 avoid the EOF or TIMEOUT exceptions add EOF or TIMEOUT to the pattern
1285 list. That will cause expect to match an EOF or TIMEOUT condition
1285 list. That will cause expect to match an EOF or TIMEOUT condition
1286 instead of raising an exception.
1286 instead of raising an exception.
1287
1287
1288 If you pass a list of patterns and more than one matches, the first match
1288 If you pass a list of patterns and more than one matches, the first match
1289 in the stream is chosen. If more than one pattern matches at that point,
1289 in the stream is chosen. If more than one pattern matches at that point,
1290 the leftmost in the pattern list is chosen. For example::
1290 the leftmost in the pattern list is chosen. For example::
1291
1291
1292 # the input is 'foobar'
1292 # the input is 'foobar'
1293 index = p.expect (['bar', 'foo', 'foobar'])
1293 index = p.expect (['bar', 'foo', 'foobar'])
1294 # returns 1 ('foo') even though 'foobar' is a "better" match
1294 # returns 1 ('foo') even though 'foobar' is a "better" match
1295
1295
1296 Please note, however, that buffering can affect this behavior, since
1296 Please note, however, that buffering can affect this behavior, since
1297 input arrives in unpredictable chunks. For example::
1297 input arrives in unpredictable chunks. For example::
1298
1298
1299 # the input is 'foobar'
1299 # the input is 'foobar'
1300 index = p.expect (['foobar', 'foo'])
1300 index = p.expect (['foobar', 'foo'])
1301 # returns 0 ('foobar') if all input is available at once,
1301 # returns 0 ('foobar') if all input is available at once,
1302 # but returs 1 ('foo') if parts of the final 'bar' arrive late
1302 # but returs 1 ('foo') if parts of the final 'bar' arrive late
1303
1303
1304 After a match is found the instance attributes 'before', 'after' and
1304 After a match is found the instance attributes 'before', 'after' and
1305 'match' will be set. You can see all the data read before the match in
1305 'match' will be set. You can see all the data read before the match in
1306 'before'. You can see the data that was matched in 'after'. The
1306 'before'. You can see the data that was matched in 'after'. The
1307 re.MatchObject used in the re match will be in 'match'. If an error
1307 re.MatchObject used in the re match will be in 'match'. If an error
1308 occurred then 'before' will be set to all the data read so far and
1308 occurred then 'before' will be set to all the data read so far and
1309 'after' and 'match' will be None.
1309 'after' and 'match' will be None.
1310
1310
1311 If timeout is -1 then timeout will be set to the self.timeout value.
1311 If timeout is -1 then timeout will be set to the self.timeout value.
1312
1312
1313 A list entry may be EOF or TIMEOUT instead of a string. This will
1313 A list entry may be EOF or TIMEOUT instead of a string. This will
1314 catch these exceptions and return the index of the list entry instead
1314 catch these exceptions and return the index of the list entry instead
1315 of raising the exception. The attribute 'after' will be set to the
1315 of raising the exception. The attribute 'after' will be set to the
1316 exception type. The attribute 'match' will be None. This allows you to
1316 exception type. The attribute 'match' will be None. This allows you to
1317 write code like this::
1317 write code like this::
1318
1318
1319 index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])
1319 index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])
1320 if index == 0:
1320 if index == 0:
1321 do_something()
1321 do_something()
1322 elif index == 1:
1322 elif index == 1:
1323 do_something_else()
1323 do_something_else()
1324 elif index == 2:
1324 elif index == 2:
1325 do_some_other_thing()
1325 do_some_other_thing()
1326 elif index == 3:
1326 elif index == 3:
1327 do_something_completely_different()
1327 do_something_completely_different()
1328
1328
1329 instead of code like this::
1329 instead of code like this::
1330
1330
1331 try:
1331 try:
1332 index = p.expect (['good', 'bad'])
1332 index = p.expect (['good', 'bad'])
1333 if index == 0:
1333 if index == 0:
1334 do_something()
1334 do_something()
1335 elif index == 1:
1335 elif index == 1:
1336 do_something_else()
1336 do_something_else()
1337 except EOF:
1337 except EOF:
1338 do_some_other_thing()
1338 do_some_other_thing()
1339 except TIMEOUT:
1339 except TIMEOUT:
1340 do_something_completely_different()
1340 do_something_completely_different()
1341
1341
1342 These two forms are equivalent. It all depends on what you want. You
1342 These two forms are equivalent. It all depends on what you want. You
1343 can also just expect the EOF if you are waiting for all output of a
1343 can also just expect the EOF if you are waiting for all output of a
1344 child to finish. For example::
1344 child to finish. For example::
1345
1345
1346 p = pexpect.spawn('/bin/ls')
1346 p = pexpect.spawn('/bin/ls')
1347 p.expect (pexpect.EOF)
1347 p.expect (pexpect.EOF)
1348 print p.before
1348 print p.before
1349
1349
1350 If you are trying to optimize for speed then see expect_list().
1350 If you are trying to optimize for speed then see expect_list().
1351 """
1351 """
1352
1352
1353 compiled_pattern_list = self.compile_pattern_list(pattern)
1353 compiled_pattern_list = self.compile_pattern_list(pattern)
1354 return self.expect_list(compiled_pattern_list, timeout, searchwindowsize)
1354 return self.expect_list(compiled_pattern_list, timeout, searchwindowsize)
1355
1355
1356 def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1):
1356 def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1):
1357
1357
1358 """This takes a list of compiled regular expressions and returns the
1358 """This takes a list of compiled regular expressions and returns the
1359 index into the pattern_list that matched the child output. The list may
1359 index into the pattern_list that matched the child output. The list may
1360 also contain EOF or TIMEOUT (which are not compiled regular
1360 also contain EOF or TIMEOUT (which are not compiled regular
1361 expressions). This method is similar to the expect() method except that
1361 expressions). This method is similar to the expect() method except that
1362 expect_list() does not recompile the pattern list on every call. This
1362 expect_list() does not recompile the pattern list on every call. This
1363 may help if you are trying to optimize for speed, otherwise just use
1363 may help if you are trying to optimize for speed, otherwise just use
1364 the expect() method. This is called by expect(). If timeout==-1 then
1364 the expect() method. This is called by expect(). If timeout==-1 then
1365 the self.timeout value is used. If searchwindowsize==-1 then the
1365 the self.timeout value is used. If searchwindowsize==-1 then the
1366 self.searchwindowsize value is used. """
1366 self.searchwindowsize value is used. """
1367
1367
1368 return self.expect_loop(searcher_re(pattern_list), timeout, searchwindowsize)
1368 return self.expect_loop(searcher_re(pattern_list), timeout, searchwindowsize)
1369
1369
1370 def expect_exact(self, pattern_list, timeout = -1, searchwindowsize = -1):
1370 def expect_exact(self, pattern_list, timeout = -1, searchwindowsize = -1):
1371
1371
1372 """This is similar to expect(), but uses plain string matching instead
1372 """This is similar to expect(), but uses plain string matching instead
1373 of compiled regular expressions in 'pattern_list'. The 'pattern_list'
1373 of compiled regular expressions in 'pattern_list'. The 'pattern_list'
1374 may be a string; a list or other sequence of strings; or TIMEOUT and
1374 may be a string; a list or other sequence of strings; or TIMEOUT and
1375 EOF.
1375 EOF.
1376
1376
1377 This call might be faster than expect() for two reasons: string
1377 This call might be faster than expect() for two reasons: string
1378 searching is faster than RE matching and it is possible to limit the
1378 searching is faster than RE matching and it is possible to limit the
1379 search to just the end of the input buffer.
1379 search to just the end of the input buffer.
1380
1380
1381 This method is also useful when you don't want to have to worry about
1381 This method is also useful when you don't want to have to worry about
1382 escaping regular expression characters that you want to match."""
1382 escaping regular expression characters that you want to match."""
1383
1383
1384 if isinstance(pattern_list, (bytes, unicode)) or pattern_list in (TIMEOUT, EOF):
1384 if isinstance(pattern_list, (bytes, unicode)) or pattern_list in (TIMEOUT, EOF):
1385 pattern_list = [pattern_list]
1385 pattern_list = [pattern_list]
1386 return self.expect_loop(searcher_string(pattern_list), timeout, searchwindowsize)
1386 return self.expect_loop(searcher_string(pattern_list), timeout, searchwindowsize)
1387
1387
1388 def expect_loop(self, searcher, timeout = -1, searchwindowsize = -1):
1388 def expect_loop(self, searcher, timeout = -1, searchwindowsize = -1):
1389
1389
1390 """This is the common loop used inside expect. The 'searcher' should be
1390 """This is the common loop used inside expect. The 'searcher' should be
1391 an instance of searcher_re or searcher_string, which describes how and what
1391 an instance of searcher_re or searcher_string, which describes how and what
1392 to search for in the input.
1392 to search for in the input.
1393
1393
1394 See expect() for other arguments, return value and exceptions. """
1394 See expect() for other arguments, return value and exceptions. """
1395
1395
1396 self.searcher = searcher
1396 self.searcher = searcher
1397
1397
1398 if timeout == -1:
1398 if timeout == -1:
1399 timeout = self.timeout
1399 timeout = self.timeout
1400 if timeout is not None:
1400 if timeout is not None:
1401 end_time = time.time() + timeout
1401 end_time = time.time() + timeout
1402 if searchwindowsize == -1:
1402 if searchwindowsize == -1:
1403 searchwindowsize = self.searchwindowsize
1403 searchwindowsize = self.searchwindowsize
1404
1404
1405 try:
1405 try:
1406 incoming = self.buffer
1406 incoming = self.buffer
1407 freshlen = len(incoming)
1407 freshlen = len(incoming)
1408 while True: # Keep reading until exception or return.
1408 while True: # Keep reading until exception or return.
1409 index = searcher.search(incoming, freshlen, searchwindowsize)
1409 index = searcher.search(incoming, freshlen, searchwindowsize)
1410 if index >= 0:
1410 if index >= 0:
1411 self.buffer = incoming[searcher.end : ]
1411 self.buffer = incoming[searcher.end : ]
1412 self.before = incoming[ : searcher.start]
1412 self.before = incoming[ : searcher.start]
1413 self.after = incoming[searcher.start : searcher.end]
1413 self.after = incoming[searcher.start : searcher.end]
1414 self.match = searcher.match
1414 self.match = searcher.match
1415 self.match_index = index
1415 self.match_index = index
1416 return self.match_index
1416 return self.match_index
1417 # No match at this point
1417 # No match at this point
1418 if timeout is not None and timeout < 0:
1418 if timeout is not None and timeout < 0:
1419 raise TIMEOUT ('Timeout exceeded in expect_any().')
1419 raise TIMEOUT ('Timeout exceeded in expect_any().')
1420 # Still have time left, so read more data
1420 # Still have time left, so read more data
1421 c = self.read_nonblocking (self.maxread, timeout)
1421 c = self.read_nonblocking (self.maxread, timeout)
1422 freshlen = len(c)
1422 freshlen = len(c)
1423 time.sleep (0.0001)
1423 time.sleep (0.0001)
1424 incoming = incoming + c
1424 incoming = incoming + c
1425 if timeout is not None:
1425 if timeout is not None:
1426 timeout = end_time - time.time()
1426 timeout = end_time - time.time()
1427 except EOF, e:
1427 except EOF, e:
1428 self.buffer = self._empty_buffer
1428 self.buffer = self._empty_buffer
1429 self.before = incoming
1429 self.before = incoming
1430 self.after = EOF
1430 self.after = EOF
1431 index = searcher.eof_index
1431 index = searcher.eof_index
1432 if index >= 0:
1432 if index >= 0:
1433 self.match = EOF
1433 self.match = EOF
1434 self.match_index = index
1434 self.match_index = index
1435 return self.match_index
1435 return self.match_index
1436 else:
1436 else:
1437 self.match = None
1437 self.match = None
1438 self.match_index = None
1438 self.match_index = None
1439 raise EOF (str(e) + '\n' + str(self))
1439 raise EOF (str(e) + '\n' + str(self))
1440 except TIMEOUT, e:
1440 except TIMEOUT, e:
1441 self.buffer = incoming
1441 self.buffer = incoming
1442 self.before = incoming
1442 self.before = incoming
1443 self.after = TIMEOUT
1443 self.after = TIMEOUT
1444 index = searcher.timeout_index
1444 index = searcher.timeout_index
1445 if index >= 0:
1445 if index >= 0:
1446 self.match = TIMEOUT
1446 self.match = TIMEOUT
1447 self.match_index = index
1447 self.match_index = index
1448 return self.match_index
1448 return self.match_index
1449 else:
1449 else:
1450 self.match = None
1450 self.match = None
1451 self.match_index = None
1451 self.match_index = None
1452 raise TIMEOUT (str(e) + '\n' + str(self))
1452 raise TIMEOUT (str(e) + '\n' + str(self))
1453 except:
1453 except:
1454 self.before = incoming
1454 self.before = incoming
1455 self.after = None
1455 self.after = None
1456 self.match = None
1456 self.match = None
1457 self.match_index = None
1457 self.match_index = None
1458 raise
1458 raise
1459
1459
1460 def getwinsize(self):
1460 def getwinsize(self):
1461
1461
1462 """This returns the terminal window size of the child tty. The return
1462 """This returns the terminal window size of the child tty. The return
1463 value is a tuple of (rows, cols). """
1463 value is a tuple of (rows, cols). """
1464
1464
1465 TIOCGWINSZ = getattr(termios, 'TIOCGWINSZ', 1074295912L)
1465 TIOCGWINSZ = getattr(termios, 'TIOCGWINSZ', 1074295912L)
1466 s = struct.pack('HHHH', 0, 0, 0, 0)
1466 s = struct.pack('HHHH', 0, 0, 0, 0)
1467 x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s)
1467 x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s)
1468 return struct.unpack('HHHH', x)[0:2]
1468 return struct.unpack('HHHH', x)[0:2]
1469
1469
1470 def setwinsize(self, r, c):
1470 def setwinsize(self, r, c):
1471
1471
1472 """This sets the terminal window size of the child tty. This will cause
1472 """This sets the terminal window size of the child tty. This will cause
1473 a SIGWINCH signal to be sent to the child. This does not change the
1473 a SIGWINCH signal to be sent to the child. This does not change the
1474 physical window size. It changes the size reported to TTY-aware
1474 physical window size. It changes the size reported to TTY-aware
1475 applications like vi or curses -- applications that respond to the
1475 applications like vi or curses -- applications that respond to the
1476 SIGWINCH signal. """
1476 SIGWINCH signal. """
1477
1477
1478 # Check for buggy platforms. Some Python versions on some platforms
1478 # Check for buggy platforms. Some Python versions on some platforms
1479 # (notably OSF1 Alpha and RedHat 7.1) truncate the value for
1479 # (notably OSF1 Alpha and RedHat 7.1) truncate the value for
1480 # termios.TIOCSWINSZ. It is not clear why this happens.
1480 # termios.TIOCSWINSZ. It is not clear why this happens.
1481 # These platforms don't seem to handle the signed int very well;
1481 # These platforms don't seem to handle the signed int very well;
1482 # yet other platforms like OpenBSD have a large negative value for
1482 # yet other platforms like OpenBSD have a large negative value for
1483 # TIOCSWINSZ and they don't have a truncate problem.
1483 # TIOCSWINSZ and they don't have a truncate problem.
1484 # Newer versions of Linux have totally different values for TIOCSWINSZ.
1484 # Newer versions of Linux have totally different values for TIOCSWINSZ.
1485 # Note that this fix is a hack.
1485 # Note that this fix is a hack.
1486 TIOCSWINSZ = getattr(termios, 'TIOCSWINSZ', -2146929561)
1486 TIOCSWINSZ = getattr(termios, 'TIOCSWINSZ', -2146929561)
1487 if TIOCSWINSZ == 2148037735L: # L is not required in Python >= 2.2.
1487 if TIOCSWINSZ == 2148037735L: # L is not required in Python >= 2.2.
1488 TIOCSWINSZ = -2146929561 # Same bits, but with sign.
1488 TIOCSWINSZ = -2146929561 # Same bits, but with sign.
1489 # Note, assume ws_xpixel and ws_ypixel are zero.
1489 # Note, assume ws_xpixel and ws_ypixel are zero.
1490 s = struct.pack('HHHH', r, c, 0, 0)
1490 s = struct.pack('HHHH', r, c, 0, 0)
1491 fcntl.ioctl(self.fileno(), TIOCSWINSZ, s)
1491 fcntl.ioctl(self.fileno(), TIOCSWINSZ, s)
1492
1492
1493 def interact(self, escape_character = b'\x1d', input_filter = None, output_filter = None):
1493 def interact(self, escape_character = b'\x1d', input_filter = None, output_filter = None):
1494
1494
1495 """This gives control of the child process to the interactive user (the
1495 """This gives control of the child process to the interactive user (the
1496 human at the keyboard). Keystrokes are sent to the child process, and
1496 human at the keyboard). Keystrokes are sent to the child process, and
1497 the stdout and stderr output of the child process is printed. This
1497 the stdout and stderr output of the child process is printed. This
1498 simply echos the child stdout and child stderr to the real stdout and
1498 simply echos the child stdout and child stderr to the real stdout and
1499 it echos the real stdin to the child stdin. When the user types the
1499 it echos the real stdin to the child stdin. When the user types the
1500 escape_character this method will stop. The default for
1500 escape_character this method will stop. The default for
1501 escape_character is ^]. This should not be confused with ASCII 27 --
1501 escape_character is ^]. This should not be confused with ASCII 27 --
1502 the ESC character. ASCII 29 was chosen for historical merit because
1502 the ESC character. ASCII 29 was chosen for historical merit because
1503 this is the character used by 'telnet' as the escape character. The
1503 this is the character used by 'telnet' as the escape character. The
1504 escape_character will not be sent to the child process.
1504 escape_character will not be sent to the child process.
1505
1505
1506 You may pass in optional input and output filter functions. These
1506 You may pass in optional input and output filter functions. These
1507 functions should take a string and return a string. The output_filter
1507 functions should take a string and return a string. The output_filter
1508 will be passed all the output from the child process. The input_filter
1508 will be passed all the output from the child process. The input_filter
1509 will be passed all the keyboard input from the user. The input_filter
1509 will be passed all the keyboard input from the user. The input_filter
1510 is run BEFORE the check for the escape_character.
1510 is run BEFORE the check for the escape_character.
1511
1511
1512 Note that if you change the window size of the parent the SIGWINCH
1512 Note that if you change the window size of the parent the SIGWINCH
1513 signal will not be passed through to the child. If you want the child
1513 signal will not be passed through to the child. If you want the child
1514 window size to change when the parent's window size changes then do
1514 window size to change when the parent's window size changes then do
1515 something like the following example::
1515 something like the following example::
1516
1516
1517 import pexpect, struct, fcntl, termios, signal, sys
1517 import pexpect, struct, fcntl, termios, signal, sys
1518 def sigwinch_passthrough (sig, data):
1518 def sigwinch_passthrough (sig, data):
1519 s = struct.pack("HHHH", 0, 0, 0, 0)
1519 s = struct.pack("HHHH", 0, 0, 0, 0)
1520 a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ , s))
1520 a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ , s))
1521 global p
1521 global p
1522 p.setwinsize(a[0],a[1])
1522 p.setwinsize(a[0],a[1])
1523 p = pexpect.spawn('/bin/bash') # Note this is global and used in sigwinch_passthrough.
1523 p = pexpect.spawn('/bin/bash') # Note this is global and used in sigwinch_passthrough.
1524 signal.signal(signal.SIGWINCH, sigwinch_passthrough)
1524 signal.signal(signal.SIGWINCH, sigwinch_passthrough)
1525 p.interact()
1525 p.interact()
1526 """
1526 """
1527
1527
1528 # Flush the buffer.
1528 # Flush the buffer.
1529 if PY3: self.stdout.write(_cast_unicode(self.buffer, self.encoding))
1529 if PY3: self.stdout.write(_cast_unicode(self.buffer, self.encoding))
1530 else: self.stdout.write(self.buffer)
1530 else: self.stdout.write(self.buffer)
1531 self.stdout.flush()
1531 self.stdout.flush()
1532 self.buffer = self._empty_buffer
1532 self.buffer = self._empty_buffer
1533 mode = tty.tcgetattr(self.STDIN_FILENO)
1533 mode = tty.tcgetattr(self.STDIN_FILENO)
1534 tty.setraw(self.STDIN_FILENO)
1534 tty.setraw(self.STDIN_FILENO)
1535 try:
1535 try:
1536 self.__interact_copy(escape_character, input_filter, output_filter)
1536 self.__interact_copy(escape_character, input_filter, output_filter)
1537 finally:
1537 finally:
1538 tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode)
1538 tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode)
1539
1539
1540 def __interact_writen(self, fd, data):
1540 def __interact_writen(self, fd, data):
1541
1541
1542 """This is used by the interact() method.
1542 """This is used by the interact() method.
1543 """
1543 """
1544
1544
1545 while data != b'' and self.isalive():
1545 while data != b'' and self.isalive():
1546 n = os.write(fd, data)
1546 n = os.write(fd, data)
1547 data = data[n:]
1547 data = data[n:]
1548
1548
1549 def __interact_read(self, fd):
1549 def __interact_read(self, fd):
1550
1550
1551 """This is used by the interact() method.
1551 """This is used by the interact() method.
1552 """
1552 """
1553
1553
1554 return os.read(fd, 1000)
1554 return os.read(fd, 1000)
1555
1555
1556 def __interact_copy(self, escape_character = None, input_filter = None, output_filter = None):
1556 def __interact_copy(self, escape_character = None, input_filter = None, output_filter = None):
1557
1557
1558 """This is used by the interact() method.
1558 """This is used by the interact() method.
1559 """
1559 """
1560
1560
1561 while self.isalive():
1561 while self.isalive():
1562 r,w,e = self.__select([self.child_fd, self.STDIN_FILENO], [], [])
1562 r,w,e = self.__select([self.child_fd, self.STDIN_FILENO], [], [])
1563 if self.child_fd in r:
1563 if self.child_fd in r:
1564 data = self.__interact_read(self.child_fd)
1564 data = self.__interact_read(self.child_fd)
1565 if output_filter: data = output_filter(data)
1565 if output_filter: data = output_filter(data)
1566 if self.logfile is not None:
1566 if self.logfile is not None:
1567 self.logfile.write (data)
1567 self.logfile.write (data)
1568 self.logfile.flush()
1568 self.logfile.flush()
1569 os.write(self.STDOUT_FILENO, data)
1569 os.write(self.STDOUT_FILENO, data)
1570 if self.STDIN_FILENO in r:
1570 if self.STDIN_FILENO in r:
1571 data = self.__interact_read(self.STDIN_FILENO)
1571 data = self.__interact_read(self.STDIN_FILENO)
1572 if input_filter: data = input_filter(data)
1572 if input_filter: data = input_filter(data)
1573 i = data.rfind(escape_character)
1573 i = data.rfind(escape_character)
1574 if i != -1:
1574 if i != -1:
1575 data = data[:i]
1575 data = data[:i]
1576 self.__interact_writen(self.child_fd, data)
1576 self.__interact_writen(self.child_fd, data)
1577 break
1577 break
1578 self.__interact_writen(self.child_fd, data)
1578 self.__interact_writen(self.child_fd, data)
1579
1579
1580 def __select (self, iwtd, owtd, ewtd, timeout=None):
1580 def __select (self, iwtd, owtd, ewtd, timeout=None):
1581
1581
1582 """This is a wrapper around select.select() that ignores signals. If
1582 """This is a wrapper around select.select() that ignores signals. If
1583 select.select raises a select.error exception and errno is an EINTR
1583 select.select raises a select.error exception and errno is an EINTR
1584 error then it is ignored. Mainly this is used to ignore sigwinch
1584 error then it is ignored. Mainly this is used to ignore sigwinch
1585 (terminal resize). """
1585 (terminal resize). """
1586
1586
1587 # if select() is interrupted by a signal (errno==EINTR) then
1587 # if select() is interrupted by a signal (errno==EINTR) then
1588 # we loop back and enter the select() again.
1588 # we loop back and enter the select() again.
1589 if timeout is not None:
1589 if timeout is not None:
1590 end_time = time.time() + timeout
1590 end_time = time.time() + timeout
1591 while True:
1591 while True:
1592 try:
1592 try:
1593 return select.select (iwtd, owtd, ewtd, timeout)
1593 return select.select (iwtd, owtd, ewtd, timeout)
1594 except select.error as e:
1594 except select.error as e:
1595 if e.args[0] == errno.EINTR:
1595 if e.args[0] == errno.EINTR:
1596 # if we loop back we have to subtract the amount of time we already waited.
1596 # if we loop back we have to subtract the amount of time we already waited.
1597 if timeout is not None:
1597 if timeout is not None:
1598 timeout = end_time - time.time()
1598 timeout = end_time - time.time()
1599 if timeout < 0:
1599 if timeout < 0:
1600 return ([],[],[])
1600 return ([],[],[])
1601 else: # something else caused the select.error, so this really is an exception
1601 else: # something else caused the select.error, so this really is an exception
1602 raise
1602 raise
1603
1603
1604 class spawn(spawnb):
1604 class spawn(spawnb):
1605 """This is the main class interface for Pexpect. Use this class to start
1605 """This is the main class interface for Pexpect. Use this class to start
1606 and control child applications."""
1606 and control child applications."""
1607
1607
1608 _buffer_type = unicode
1608 _buffer_type = unicode
1609 def _cast_buffer_type(self, s):
1609 def _cast_buffer_type(self, s):
1610 return _cast_unicode(s, self.encoding)
1610 return _cast_unicode(s, self.encoding)
1611 _empty_buffer = u''
1611 _empty_buffer = u''
1612 _pty_newline = u'\r\n'
1612 _pty_newline = u'\r\n'
1613
1613
1614 def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None,
1614 def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None,
1615 logfile=None, cwd=None, env=None, encoding='utf-8'):
1615 logfile=None, cwd=None, env=None, encoding='utf-8'):
1616 super(spawn, self).__init__(command, args, timeout=timeout, maxread=maxread,
1616 super(spawn, self).__init__(command, args, timeout=timeout, maxread=maxread,
1617 searchwindowsize=searchwindowsize, logfile=logfile, cwd=cwd, env=env)
1617 searchwindowsize=searchwindowsize, logfile=logfile, cwd=cwd, env=env)
1618 self.encoding = encoding
1618 self.encoding = encoding
1619
1619
1620 def _prepare_regex_pattern(self, p):
1620 def _prepare_regex_pattern(self, p):
1621 "Recompile bytes regexes as unicode regexes."
1621 "Recompile bytes regexes as unicode regexes."
1622 if isinstance(p.pattern, bytes):
1622 if isinstance(p.pattern, bytes):
1623 p = re.compile(p.pattern.decode(self.encoding), p.flags)
1623 p = re.compile(p.pattern.decode(self.encoding), p.flags)
1624 return p
1624 return p
1625
1625
1626 def read_nonblocking(self, size=1, timeout=-1):
1626 def read_nonblocking(self, size=1, timeout=-1):
1627 return super(spawn, self).read_nonblocking(size=size, timeout=timeout)\
1627 return super(spawn, self).read_nonblocking(size=size, timeout=timeout)\
1628 .decode(self.encoding)
1628 .decode(self.encoding)
1629
1629
1630 read_nonblocking.__doc__ = spawnb.read_nonblocking.__doc__
1630 read_nonblocking.__doc__ = spawnb.read_nonblocking.__doc__
1631
1631
1632
1632
1633 ##############################################################################
1633 ##############################################################################
1634 # End of spawn class
1634 # End of spawn class
1635 ##############################################################################
1635 ##############################################################################
1636
1636
1637 class searcher_string (object):
1637 class searcher_string (object):
1638
1638
1639 """This is a plain string search helper for the spawn.expect_any() method.
1639 """This is a plain string search helper for the spawn.expect_any() method.
1640 This helper class is for speed. For more powerful regex patterns
1640 This helper class is for speed. For more powerful regex patterns
1641 see the helper class, searcher_re.
1641 see the helper class, searcher_re.
1642
1642
1643 Attributes:
1643 Attributes:
1644
1644
1645 eof_index - index of EOF, or -1
1645 eof_index - index of EOF, or -1
1646 timeout_index - index of TIMEOUT, or -1
1646 timeout_index - index of TIMEOUT, or -1
1647
1647
1648 After a successful match by the search() method the following attributes
1648 After a successful match by the search() method the following attributes
1649 are available:
1649 are available:
1650
1650
1651 start - index into the buffer, first byte of match
1651 start - index into the buffer, first byte of match
1652 end - index into the buffer, first byte after match
1652 end - index into the buffer, first byte after match
1653 match - the matching string itself
1653 match - the matching string itself
1654
1654
1655 """
1655 """
1656
1656
1657 def __init__(self, strings):
1657 def __init__(self, strings):
1658
1658
1659 """This creates an instance of searcher_string. This argument 'strings'
1659 """This creates an instance of searcher_string. This argument 'strings'
1660 may be a list; a sequence of strings; or the EOF or TIMEOUT types. """
1660 may be a list; a sequence of strings; or the EOF or TIMEOUT types. """
1661
1661
1662 self.eof_index = -1
1662 self.eof_index = -1
1663 self.timeout_index = -1
1663 self.timeout_index = -1
1664 self._strings = []
1664 self._strings = []
1665 for n, s in enumerate(strings):
1665 for n, s in enumerate(strings):
1666 if s is EOF:
1666 if s is EOF:
1667 self.eof_index = n
1667 self.eof_index = n
1668 continue
1668 continue
1669 if s is TIMEOUT:
1669 if s is TIMEOUT:
1670 self.timeout_index = n
1670 self.timeout_index = n
1671 continue
1671 continue
1672 self._strings.append((n, s))
1672 self._strings.append((n, s))
1673
1673
1674 def __str__(self):
1674 def __str__(self):
1675
1675
1676 """This returns a human-readable string that represents the state of
1676 """This returns a human-readable string that represents the state of
1677 the object."""
1677 the object."""
1678
1678
1679 ss = [ (ns[0],' %d: "%s"' % ns) for ns in self._strings ]
1679 ss = [ (ns[0],' %d: "%s"' % ns) for ns in self._strings ]
1680 ss.append((-1,'searcher_string:'))
1680 ss.append((-1,'searcher_string:'))
1681 if self.eof_index >= 0:
1681 if self.eof_index >= 0:
1682 ss.append ((self.eof_index,' %d: EOF' % self.eof_index))
1682 ss.append ((self.eof_index,' %d: EOF' % self.eof_index))
1683 if self.timeout_index >= 0:
1683 if self.timeout_index >= 0:
1684 ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index))
1684 ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index))
1685 ss.sort()
1685 ss.sort()
1686 return '\n'.join(a[1] for a in ss)
1686 return '\n'.join(a[1] for a in ss)
1687
1687
1688 def search(self, buffer, freshlen, searchwindowsize=None):
1688 def search(self, buffer, freshlen, searchwindowsize=None):
1689
1689
1690 """This searches 'buffer' for the first occurence of one of the search
1690 """This searches 'buffer' for the first occurence of one of the search
1691 strings. 'freshlen' must indicate the number of bytes at the end of
1691 strings. 'freshlen' must indicate the number of bytes at the end of
1692 'buffer' which have not been searched before. It helps to avoid
1692 'buffer' which have not been searched before. It helps to avoid
1693 searching the same, possibly big, buffer over and over again.
1693 searching the same, possibly big, buffer over and over again.
1694
1694
1695 See class spawn for the 'searchwindowsize' argument.
1695 See class spawn for the 'searchwindowsize' argument.
1696
1696
1697 If there is a match this returns the index of that string, and sets
1697 If there is a match this returns the index of that string, and sets
1698 'start', 'end' and 'match'. Otherwise, this returns -1. """
1698 'start', 'end' and 'match'. Otherwise, this returns -1. """
1699
1699
1700 absurd_match = len(buffer)
1700 absurd_match = len(buffer)
1701 first_match = absurd_match
1701 first_match = absurd_match
1702
1702
1703 # 'freshlen' helps a lot here. Further optimizations could
1703 # 'freshlen' helps a lot here. Further optimizations could
1704 # possibly include:
1704 # possibly include:
1705 #
1705 #
1706 # using something like the Boyer-Moore Fast String Searching
1706 # using something like the Boyer-Moore Fast String Searching
1707 # Algorithm; pre-compiling the search through a list of
1707 # Algorithm; pre-compiling the search through a list of
1708 # strings into something that can scan the input once to
1708 # strings into something that can scan the input once to
1709 # search for all N strings; realize that if we search for
1709 # search for all N strings; realize that if we search for
1710 # ['bar', 'baz'] and the input is '...foo' we need not bother
1710 # ['bar', 'baz'] and the input is '...foo' we need not bother
1711 # rescanning until we've read three more bytes.
1711 # rescanning until we've read three more bytes.
1712 #
1712 #
1713 # Sadly, I don't know enough about this interesting topic. /grahn
1713 # Sadly, I don't know enough about this interesting topic. /grahn
1714
1714
1715 for index, s in self._strings:
1715 for index, s in self._strings:
1716 if searchwindowsize is None:
1716 if searchwindowsize is None:
1717 # the match, if any, can only be in the fresh data,
1717 # the match, if any, can only be in the fresh data,
1718 # or at the very end of the old data
1718 # or at the very end of the old data
1719 offset = -(freshlen+len(s))
1719 offset = -(freshlen+len(s))
1720 else:
1720 else:
1721 # better obey searchwindowsize
1721 # better obey searchwindowsize
1722 offset = -searchwindowsize
1722 offset = -searchwindowsize
1723 n = buffer.find(s, offset)
1723 n = buffer.find(s, offset)
1724 if n >= 0 and n < first_match:
1724 if n >= 0 and n < first_match:
1725 first_match = n
1725 first_match = n
1726 best_index, best_match = index, s
1726 best_index, best_match = index, s
1727 if first_match == absurd_match:
1727 if first_match == absurd_match:
1728 return -1
1728 return -1
1729 self.match = best_match
1729 self.match = best_match
1730 self.start = first_match
1730 self.start = first_match
1731 self.end = self.start + len(self.match)
1731 self.end = self.start + len(self.match)
1732 return best_index
1732 return best_index
1733
1733
1734 class searcher_re (object):
1734 class searcher_re (object):
1735
1735
1736 """This is regular expression string search helper for the
1736 """This is regular expression string search helper for the
1737 spawn.expect_any() method. This helper class is for powerful
1737 spawn.expect_any() method. This helper class is for powerful
1738 pattern matching. For speed, see the helper class, searcher_string.
1738 pattern matching. For speed, see the helper class, searcher_string.
1739
1739
1740 Attributes:
1740 Attributes:
1741
1741
1742 eof_index - index of EOF, or -1
1742 eof_index - index of EOF, or -1
1743 timeout_index - index of TIMEOUT, or -1
1743 timeout_index - index of TIMEOUT, or -1
1744
1744
1745 After a successful match by the search() method the following attributes
1745 After a successful match by the search() method the following attributes
1746 are available:
1746 are available:
1747
1747
1748 start - index into the buffer, first byte of match
1748 start - index into the buffer, first byte of match
1749 end - index into the buffer, first byte after match
1749 end - index into the buffer, first byte after match
1750 match - the re.match object returned by a succesful re.search
1750 match - the re.match object returned by a succesful re.search
1751
1751
1752 """
1752 """
1753
1753
1754 def __init__(self, patterns):
1754 def __init__(self, patterns):
1755
1755
1756 """This creates an instance that searches for 'patterns' Where
1756 """This creates an instance that searches for 'patterns' Where
1757 'patterns' may be a list or other sequence of compiled regular
1757 'patterns' may be a list or other sequence of compiled regular
1758 expressions, or the EOF or TIMEOUT types."""
1758 expressions, or the EOF or TIMEOUT types."""
1759
1759
1760 self.eof_index = -1
1760 self.eof_index = -1
1761 self.timeout_index = -1
1761 self.timeout_index = -1
1762 self._searches = []
1762 self._searches = []
1763 for n, s in enumerate(patterns):
1763 for n, s in enumerate(patterns):
1764 if s is EOF:
1764 if s is EOF:
1765 self.eof_index = n
1765 self.eof_index = n
1766 continue
1766 continue
1767 if s is TIMEOUT:
1767 if s is TIMEOUT:
1768 self.timeout_index = n
1768 self.timeout_index = n
1769 continue
1769 continue
1770 self._searches.append((n, s))
1770 self._searches.append((n, s))
1771
1771
1772 def __str__(self):
1772 def __str__(self):
1773
1773
1774 """This returns a human-readable string that represents the state of
1774 """This returns a human-readable string that represents the state of
1775 the object."""
1775 the object."""
1776
1776
1777 ss = [ (n,' %d: re.compile("%s")' % (n,str(s.pattern))) for n,s in self._searches]
1777 ss = [ (n,' %d: re.compile("%s")' % (n,str(s.pattern))) for n,s in self._searches]
1778 ss.append((-1,'searcher_re:'))
1778 ss.append((-1,'searcher_re:'))
1779 if self.eof_index >= 0:
1779 if self.eof_index >= 0:
1780 ss.append ((self.eof_index,' %d: EOF' % self.eof_index))
1780 ss.append ((self.eof_index,' %d: EOF' % self.eof_index))
1781 if self.timeout_index >= 0:
1781 if self.timeout_index >= 0:
1782 ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index))
1782 ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index))
1783 ss.sort()
1783 ss.sort()
1784 return '\n'.join(a[1] for a in ss)
1784 return '\n'.join(a[1] for a in ss)
1785
1785
1786 def search(self, buffer, freshlen, searchwindowsize=None):
1786 def search(self, buffer, freshlen, searchwindowsize=None):
1787
1787
1788 """This searches 'buffer' for the first occurence of one of the regular
1788 """This searches 'buffer' for the first occurence of one of the regular
1789 expressions. 'freshlen' must indicate the number of bytes at the end of
1789 expressions. 'freshlen' must indicate the number of bytes at the end of
1790 'buffer' which have not been searched before.
1790 'buffer' which have not been searched before.
1791
1791
1792 See class spawn for the 'searchwindowsize' argument.
1792 See class spawn for the 'searchwindowsize' argument.
1793
1793
1794 If there is a match this returns the index of that string, and sets
1794 If there is a match this returns the index of that string, and sets
1795 'start', 'end' and 'match'. Otherwise, returns -1."""
1795 'start', 'end' and 'match'. Otherwise, returns -1."""
1796
1796
1797 absurd_match = len(buffer)
1797 absurd_match = len(buffer)
1798 first_match = absurd_match
1798 first_match = absurd_match
1799 # 'freshlen' doesn't help here -- we cannot predict the
1799 # 'freshlen' doesn't help here -- we cannot predict the
1800 # length of a match, and the re module provides no help.
1800 # length of a match, and the re module provides no help.
1801 if searchwindowsize is None:
1801 if searchwindowsize is None:
1802 searchstart = 0
1802 searchstart = 0
1803 else:
1803 else:
1804 searchstart = max(0, len(buffer)-searchwindowsize)
1804 searchstart = max(0, len(buffer)-searchwindowsize)
1805 for index, s in self._searches:
1805 for index, s in self._searches:
1806 match = s.search(buffer, searchstart)
1806 match = s.search(buffer, searchstart)
1807 if match is None:
1807 if match is None:
1808 continue
1808 continue
1809 n = match.start()
1809 n = match.start()
1810 if n < first_match:
1810 if n < first_match:
1811 first_match = n
1811 first_match = n
1812 the_match = match
1812 the_match = match
1813 best_index = index
1813 best_index = index
1814 if first_match == absurd_match:
1814 if first_match == absurd_match:
1815 return -1
1815 return -1
1816 self.start = first_match
1816 self.start = first_match
1817 self.match = the_match
1817 self.match = the_match
1818 self.end = self.match.end()
1818 self.end = self.match.end()
1819 return best_index
1819 return best_index
1820
1820
1821 def which (filename):
1821 def which (filename):
1822
1822
1823 """This takes a given filename; tries to find it in the environment path;
1823 """This takes a given filename; tries to find it in the environment path;
1824 then checks if it is executable. This returns the full path to the filename
1824 then checks if it is executable. This returns the full path to the filename
1825 if found and executable. Otherwise this returns None."""
1825 if found and executable. Otherwise this returns None."""
1826
1826
1827 # Special case where filename already contains a path.
1827 # Special case where filename already contains a path.
1828 if os.path.dirname(filename) != '':
1828 if os.path.dirname(filename) != '':
1829 if os.access (filename, os.X_OK):
1829 if os.access (filename, os.X_OK):
1830 return filename
1830 return filename
1831
1831
1832 if not os.environ.has_key('PATH') or os.environ['PATH'] == '':
1832 if not os.environ.has_key('PATH') or os.environ['PATH'] == '':
1833 p = os.defpath
1833 p = os.defpath
1834 else:
1834 else:
1835 p = os.environ['PATH']
1835 p = os.environ['PATH']
1836
1836
1837 pathlist = p.split(os.pathsep)
1837 pathlist = p.split(os.pathsep)
1838
1838
1839 for path in pathlist:
1839 for path in pathlist:
1840 f = os.path.join(path, filename)
1840 f = os.path.join(path, filename)
1841 if os.access(f, os.X_OK):
1841 if os.access(f, os.X_OK):
1842 return f
1842 return f
1843 return None
1843 return None
1844
1844
1845 def split_command_line(command_line):
1845 def split_command_line(command_line):
1846
1846
1847 """This splits a command line into a list of arguments. It splits arguments
1847 """This splits a command line into a list of arguments. It splits arguments
1848 on spaces, but handles embedded quotes, doublequotes, and escaped
1848 on spaces, but handles embedded quotes, doublequotes, and escaped
1849 characters. It's impossible to do this with a regular expression, so I
1849 characters. It's impossible to do this with a regular expression, so I
1850 wrote a little state machine to parse the command line. """
1850 wrote a little state machine to parse the command line. """
1851
1851
1852 arg_list = []
1852 arg_list = []
1853 arg = ''
1853 arg = ''
1854
1854
1855 # Constants to name the states we can be in.
1855 # Constants to name the states we can be in.
1856 state_basic = 0
1856 state_basic = 0
1857 state_esc = 1
1857 state_esc = 1
1858 state_singlequote = 2
1858 state_singlequote = 2
1859 state_doublequote = 3
1859 state_doublequote = 3
1860 state_whitespace = 4 # The state of consuming whitespace between commands.
1860 state_whitespace = 4 # The state of consuming whitespace between commands.
1861 state = state_basic
1861 state = state_basic
1862
1862
1863 for c in command_line:
1863 for c in command_line:
1864 if state == state_basic or state == state_whitespace:
1864 if state == state_basic or state == state_whitespace:
1865 if c == '\\': # Escape the next character
1865 if c == '\\': # Escape the next character
1866 state = state_esc
1866 state = state_esc
1867 elif c == r"'": # Handle single quote
1867 elif c == r"'": # Handle single quote
1868 state = state_singlequote
1868 state = state_singlequote
1869 elif c == r'"': # Handle double quote
1869 elif c == r'"': # Handle double quote
1870 state = state_doublequote
1870 state = state_doublequote
1871 elif c.isspace():
1871 elif c.isspace():
1872 # Add arg to arg_list if we aren't in the middle of whitespace.
1872 # Add arg to arg_list if we aren't in the middle of whitespace.
1873 if state == state_whitespace:
1873 if state == state_whitespace:
1874 None # Do nothing.
1874 None # Do nothing.
1875 else:
1875 else:
1876 arg_list.append(arg)
1876 arg_list.append(arg)
1877 arg = ''
1877 arg = ''
1878 state = state_whitespace
1878 state = state_whitespace
1879 else:
1879 else:
1880 arg = arg + c
1880 arg = arg + c
1881 state = state_basic
1881 state = state_basic
1882 elif state == state_esc:
1882 elif state == state_esc:
1883 arg = arg + c
1883 arg = arg + c
1884 state = state_basic
1884 state = state_basic
1885 elif state == state_singlequote:
1885 elif state == state_singlequote:
1886 if c == r"'":
1886 if c == r"'":
1887 state = state_basic
1887 state = state_basic
1888 else:
1888 else:
1889 arg = arg + c
1889 arg = arg + c
1890 elif state == state_doublequote:
1890 elif state == state_doublequote:
1891 if c == r'"':
1891 if c == r'"':
1892 state = state_basic
1892 state = state_basic
1893 else:
1893 else:
1894 arg = arg + c
1894 arg = arg + c
1895
1895
1896 if arg != '':
1896 if arg != '':
1897 arg_list.append(arg)
1897 arg_list.append(arg)
1898 return arg_list
1898 return arg_list
1899
1899
1900 # vi:set sr et ts=4 sw=4 ft=python :
1900 # vi:set sr et ts=4 sw=4 ft=python :
@@ -1,668 +1,668 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Subclass of InteractiveShell for terminal based frontends."""
2 """Subclass of InteractiveShell for terminal based frontends."""
3
3
4 #-----------------------------------------------------------------------------
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 # Copyright (C) 2008-2011 The IPython Development Team
7 # Copyright (C) 2008-2011 The IPython Development Team
8 #
8 #
9 # Distributed under the terms of the BSD License. The full license is in
9 # Distributed under the terms of the BSD License. The full license is in
10 # the file COPYING, distributed as part of this software.
10 # the file COPYING, distributed as part of this software.
11 #-----------------------------------------------------------------------------
11 #-----------------------------------------------------------------------------
12
12
13 #-----------------------------------------------------------------------------
13 #-----------------------------------------------------------------------------
14 # Imports
14 # Imports
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16
16
17 import __builtin__
17 import __builtin__
18 import bdb
18 import bdb
19 import os
19 import os
20 import re
20 import re
21 import sys
21 import sys
22 import textwrap
22 import textwrap
23
23
24 try:
24 try:
25 from contextlib import nested
25 from contextlib import nested
26 except:
26 except:
27 from IPython.utils.nested_context import nested
27 from IPython.utils.nested_context import nested
28
28
29 from IPython.core.error import TryNext, UsageError
29 from IPython.core.error import TryNext, UsageError
30 from IPython.core.usage import interactive_usage, default_banner
30 from IPython.core.usage import interactive_usage, default_banner
31 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
31 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
32 from IPython.core.pylabtools import pylab_activate
32 from IPython.core.pylabtools import pylab_activate
33 from IPython.testing.skipdoctest import skip_doctest
33 from IPython.testing.skipdoctest import skip_doctest
34 from IPython.utils import py3compat
34 from IPython.utils import py3compat
35 from IPython.utils.terminal import toggle_set_term_title, set_term_title
35 from IPython.utils.terminal import toggle_set_term_title, set_term_title
36 from IPython.utils.process import abbrev_cwd
36 from IPython.utils.process import abbrev_cwd
37 from IPython.utils.warn import warn, error
37 from IPython.utils.warn import warn, error
38 from IPython.utils.text import num_ini_spaces, SList
38 from IPython.utils.text import num_ini_spaces, SList
39 from IPython.utils.traitlets import Integer, CBool, Unicode
39 from IPython.utils.traitlets import Integer, CBool, Unicode
40
40
41 #-----------------------------------------------------------------------------
41 #-----------------------------------------------------------------------------
42 # Utilities
42 # Utilities
43 #-----------------------------------------------------------------------------
43 #-----------------------------------------------------------------------------
44
44
45 def get_default_editor():
45 def get_default_editor():
46 try:
46 try:
47 ed = os.environ['EDITOR']
47 ed = os.environ['EDITOR']
48 except KeyError:
48 except KeyError:
49 if os.name == 'posix':
49 if os.name == 'posix':
50 ed = 'vi' # the only one guaranteed to be there!
50 ed = 'vi' # the only one guaranteed to be there!
51 else:
51 else:
52 ed = 'notepad' # same in Windows!
52 ed = 'notepad' # same in Windows!
53 return ed
53 return ed
54
54
55
55
56 def get_pasted_lines(sentinel, l_input=py3compat.input):
56 def get_pasted_lines(sentinel, l_input=py3compat.input):
57 """ Yield pasted lines until the user enters the given sentinel value.
57 """ Yield pasted lines until the user enters the given sentinel value.
58 """
58 """
59 print "Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
59 print "Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
60 % sentinel
60 % sentinel
61 while True:
61 while True:
62 try:
62 try:
63 l = l_input(':')
63 l = l_input(':')
64 if l == sentinel:
64 if l == sentinel:
65 return
65 return
66 else:
66 else:
67 yield l
67 yield l
68 except EOFError:
68 except EOFError:
69 print '<EOF>'
69 print '<EOF>'
70 return
70 return
71
71
72
72
73 def strip_email_quotes(raw_lines):
73 def strip_email_quotes(raw_lines):
74 """ Strip email quotation marks at the beginning of each line.
74 """ Strip email quotation marks at the beginning of each line.
75
75
76 We don't do any more input transofrmations here because the main shell's
76 We don't do any more input transofrmations here because the main shell's
77 prefiltering handles other cases.
77 prefiltering handles other cases.
78 """
78 """
79 lines = [re.sub(r'^\s*(\s?>)+', '', l) for l in raw_lines]
79 lines = [re.sub(r'^\s*(\s?>)+', '', l) for l in raw_lines]
80 return '\n'.join(lines) + '\n'
80 return '\n'.join(lines) + '\n'
81
81
82
82
83 # These two functions are needed by the %paste/%cpaste magics. In practice
83 # These two functions are needed by the %paste/%cpaste magics. In practice
84 # they are basically methods (they take the shell as their first argument), but
84 # they are basically methods (they take the shell as their first argument), but
85 # we leave them as standalone functions because eventually the magics
85 # we leave them as standalone functions because eventually the magics
86 # themselves will become separate objects altogether. At that point, the
86 # themselves will become separate objects altogether. At that point, the
87 # magics will have access to the shell object, and these functions can be made
87 # magics will have access to the shell object, and these functions can be made
88 # methods of the magic object, but not of the shell.
88 # methods of the magic object, but not of the shell.
89
89
90 def store_or_execute(shell, block, name):
90 def store_or_execute(shell, block, name):
91 """ Execute a block, or store it in a variable, per the user's request.
91 """ Execute a block, or store it in a variable, per the user's request.
92 """
92 """
93 # Dedent and prefilter so what we store matches what is executed by
93 # Dedent and prefilter so what we store matches what is executed by
94 # run_cell.
94 # run_cell.
95 b = shell.prefilter(textwrap.dedent(block))
95 b = shell.prefilter(textwrap.dedent(block))
96
96
97 if name:
97 if name:
98 # If storing it for further editing, run the prefilter on it
98 # If storing it for further editing, run the prefilter on it
99 shell.user_ns[name] = SList(b.splitlines())
99 shell.user_ns[name] = SList(b.splitlines())
100 print "Block assigned to '%s'" % name
100 print "Block assigned to '%s'" % name
101 else:
101 else:
102 shell.user_ns['pasted_block'] = b
102 shell.user_ns['pasted_block'] = b
103 shell.run_cell(b)
103 shell.run_cell(b)
104
104
105
105
106 def rerun_pasted(shell, name='pasted_block'):
106 def rerun_pasted(shell, name='pasted_block'):
107 """ Rerun a previously pasted command.
107 """ Rerun a previously pasted command.
108 """
108 """
109 b = shell.user_ns.get(name)
109 b = shell.user_ns.get(name)
110
110
111 # Sanity checks
111 # Sanity checks
112 if b is None:
112 if b is None:
113 raise UsageError('No previous pasted block available')
113 raise UsageError('No previous pasted block available')
114 if not isinstance(b, basestring):
114 if not isinstance(b, basestring):
115 raise UsageError(
115 raise UsageError(
116 "Variable 'pasted_block' is not a string, can't execute")
116 "Variable 'pasted_block' is not a string, can't execute")
117
117
118 print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
118 print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
119 shell.run_cell(b)
119 shell.run_cell(b)
120
120
121
121
122 #-----------------------------------------------------------------------------
122 #-----------------------------------------------------------------------------
123 # Main class
123 # Main class
124 #-----------------------------------------------------------------------------
124 #-----------------------------------------------------------------------------
125
125
126 class TerminalInteractiveShell(InteractiveShell):
126 class TerminalInteractiveShell(InteractiveShell):
127
127
128 autoedit_syntax = CBool(False, config=True,
128 autoedit_syntax = CBool(False, config=True,
129 help="auto editing of files with syntax errors.")
129 help="auto editing of files with syntax errors.")
130 banner = Unicode('')
130 banner = Unicode('')
131 banner1 = Unicode(default_banner, config=True,
131 banner1 = Unicode(default_banner, config=True,
132 help="""The part of the banner to be printed before the profile"""
132 help="""The part of the banner to be printed before the profile"""
133 )
133 )
134 banner2 = Unicode('', config=True,
134 banner2 = Unicode('', config=True,
135 help="""The part of the banner to be printed after the profile"""
135 help="""The part of the banner to be printed after the profile"""
136 )
136 )
137 confirm_exit = CBool(True, config=True,
137 confirm_exit = CBool(True, config=True,
138 help="""
138 help="""
139 Set to confirm when you try to exit IPython with an EOF (Control-D
139 Set to confirm when you try to exit IPython with an EOF (Control-D
140 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
140 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
141 you can force a direct exit without any confirmation.""",
141 you can force a direct exit without any confirmation.""",
142 )
142 )
143 # This display_banner only controls whether or not self.show_banner()
143 # This display_banner only controls whether or not self.show_banner()
144 # is called when mainloop/interact are called. The default is False
144 # is called when mainloop/interact are called. The default is False
145 # because for the terminal based application, the banner behavior
145 # because for the terminal based application, the banner behavior
146 # is controlled by Global.display_banner, which IPythonApp looks at
146 # is controlled by Global.display_banner, which IPythonApp looks at
147 # to determine if *it* should call show_banner() by hand or not.
147 # to determine if *it* should call show_banner() by hand or not.
148 display_banner = CBool(False) # This isn't configurable!
148 display_banner = CBool(False) # This isn't configurable!
149 embedded = CBool(False)
149 embedded = CBool(False)
150 embedded_active = CBool(False)
150 embedded_active = CBool(False)
151 editor = Unicode(get_default_editor(), config=True,
151 editor = Unicode(get_default_editor(), config=True,
152 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
152 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
153 )
153 )
154 pager = Unicode('less', config=True,
154 pager = Unicode('less', config=True,
155 help="The shell program to be used for paging.")
155 help="The shell program to be used for paging.")
156
156
157 screen_length = Integer(0, config=True,
157 screen_length = Integer(0, config=True,
158 help=
158 help=
159 """Number of lines of your screen, used to control printing of very
159 """Number of lines of your screen, used to control printing of very
160 long strings. Strings longer than this number of lines will be sent
160 long strings. Strings longer than this number of lines will be sent
161 through a pager instead of directly printed. The default value for
161 through a pager instead of directly printed. The default value for
162 this is 0, which means IPython will auto-detect your screen size every
162 this is 0, which means IPython will auto-detect your screen size every
163 time it needs to print certain potentially long strings (this doesn't
163 time it needs to print certain potentially long strings (this doesn't
164 change the behavior of the 'print' keyword, it's only triggered
164 change the behavior of the 'print' keyword, it's only triggered
165 internally). If for some reason this isn't working well (it needs
165 internally). If for some reason this isn't working well (it needs
166 curses support), specify it yourself. Otherwise don't change the
166 curses support), specify it yourself. Otherwise don't change the
167 default.""",
167 default.""",
168 )
168 )
169 term_title = CBool(False, config=True,
169 term_title = CBool(False, config=True,
170 help="Enable auto setting the terminal title."
170 help="Enable auto setting the terminal title."
171 )
171 )
172
172
173 # In the terminal, GUI control is done via PyOS_InputHook
173 # In the terminal, GUI control is done via PyOS_InputHook
174 from IPython.lib.inputhook import enable_gui
174 from IPython.lib.inputhook import enable_gui
175 enable_gui = staticmethod(enable_gui)
175 enable_gui = staticmethod(enable_gui)
176
176
177 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
177 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
178 user_ns=None, user_module=None, custom_exceptions=((),None),
178 user_ns=None, user_module=None, custom_exceptions=((),None),
179 usage=None, banner1=None, banner2=None, display_banner=None):
179 usage=None, banner1=None, banner2=None, display_banner=None):
180
180
181 super(TerminalInteractiveShell, self).__init__(
181 super(TerminalInteractiveShell, self).__init__(
182 config=config, profile_dir=profile_dir, user_ns=user_ns,
182 config=config, profile_dir=profile_dir, user_ns=user_ns,
183 user_module=user_module, custom_exceptions=custom_exceptions
183 user_module=user_module, custom_exceptions=custom_exceptions
184 )
184 )
185 # use os.system instead of utils.process.system by default,
185 # use os.system instead of utils.process.system by default,
186 # because piped system doesn't make sense in the Terminal:
186 # because piped system doesn't make sense in the Terminal:
187 self.system = self.system_raw
187 self.system = self.system_raw
188
188
189 self.init_term_title()
189 self.init_term_title()
190 self.init_usage(usage)
190 self.init_usage(usage)
191 self.init_banner(banner1, banner2, display_banner)
191 self.init_banner(banner1, banner2, display_banner)
192
192
193 #-------------------------------------------------------------------------
193 #-------------------------------------------------------------------------
194 # Things related to the terminal
194 # Things related to the terminal
195 #-------------------------------------------------------------------------
195 #-------------------------------------------------------------------------
196
196
197 @property
197 @property
198 def usable_screen_length(self):
198 def usable_screen_length(self):
199 if self.screen_length == 0:
199 if self.screen_length == 0:
200 return 0
200 return 0
201 else:
201 else:
202 num_lines_bot = self.separate_in.count('\n')+1
202 num_lines_bot = self.separate_in.count('\n')+1
203 return self.screen_length - num_lines_bot
203 return self.screen_length - num_lines_bot
204
204
205 def init_term_title(self):
205 def init_term_title(self):
206 # Enable or disable the terminal title.
206 # Enable or disable the terminal title.
207 if self.term_title:
207 if self.term_title:
208 toggle_set_term_title(True)
208 toggle_set_term_title(True)
209 set_term_title('IPython: ' + abbrev_cwd())
209 set_term_title('IPython: ' + abbrev_cwd())
210 else:
210 else:
211 toggle_set_term_title(False)
211 toggle_set_term_title(False)
212
212
213 #-------------------------------------------------------------------------
213 #-------------------------------------------------------------------------
214 # Things related to aliases
214 # Things related to aliases
215 #-------------------------------------------------------------------------
215 #-------------------------------------------------------------------------
216
216
217 def init_alias(self):
217 def init_alias(self):
218 # The parent class defines aliases that can be safely used with any
218 # The parent class defines aliases that can be safely used with any
219 # frontend.
219 # frontend.
220 super(TerminalInteractiveShell, self).init_alias()
220 super(TerminalInteractiveShell, self).init_alias()
221
221
222 # Now define aliases that only make sense on the terminal, because they
222 # Now define aliases that only make sense on the terminal, because they
223 # need direct access to the console in a way that we can't emulate in
223 # need direct access to the console in a way that we can't emulate in
224 # GUI or web frontend
224 # GUI or web frontend
225 if os.name == 'posix':
225 if os.name == 'posix':
226 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
226 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
227 ('man', 'man')]
227 ('man', 'man')]
228 elif os.name == 'nt':
228 elif os.name == 'nt':
229 aliases = [('cls', 'cls')]
229 aliases = [('cls', 'cls')]
230
230
231
231
232 for name, cmd in aliases:
232 for name, cmd in aliases:
233 self.alias_manager.define_alias(name, cmd)
233 self.alias_manager.define_alias(name, cmd)
234
234
235 #-------------------------------------------------------------------------
235 #-------------------------------------------------------------------------
236 # Things related to the banner and usage
236 # Things related to the banner and usage
237 #-------------------------------------------------------------------------
237 #-------------------------------------------------------------------------
238
238
239 def _banner1_changed(self):
239 def _banner1_changed(self):
240 self.compute_banner()
240 self.compute_banner()
241
241
242 def _banner2_changed(self):
242 def _banner2_changed(self):
243 self.compute_banner()
243 self.compute_banner()
244
244
245 def _term_title_changed(self, name, new_value):
245 def _term_title_changed(self, name, new_value):
246 self.init_term_title()
246 self.init_term_title()
247
247
248 def init_banner(self, banner1, banner2, display_banner):
248 def init_banner(self, banner1, banner2, display_banner):
249 if banner1 is not None:
249 if banner1 is not None:
250 self.banner1 = banner1
250 self.banner1 = banner1
251 if banner2 is not None:
251 if banner2 is not None:
252 self.banner2 = banner2
252 self.banner2 = banner2
253 if display_banner is not None:
253 if display_banner is not None:
254 self.display_banner = display_banner
254 self.display_banner = display_banner
255 self.compute_banner()
255 self.compute_banner()
256
256
257 def show_banner(self, banner=None):
257 def show_banner(self, banner=None):
258 if banner is None:
258 if banner is None:
259 banner = self.banner
259 banner = self.banner
260 self.write(banner)
260 self.write(banner)
261
261
262 def compute_banner(self):
262 def compute_banner(self):
263 self.banner = self.banner1
263 self.banner = self.banner1
264 if self.profile and self.profile != 'default':
264 if self.profile and self.profile != 'default':
265 self.banner += '\nIPython profile: %s\n' % self.profile
265 self.banner += '\nIPython profile: %s\n' % self.profile
266 if self.banner2:
266 if self.banner2:
267 self.banner += '\n' + self.banner2
267 self.banner += '\n' + self.banner2
268
268
269 def init_usage(self, usage=None):
269 def init_usage(self, usage=None):
270 if usage is None:
270 if usage is None:
271 self.usage = interactive_usage
271 self.usage = interactive_usage
272 else:
272 else:
273 self.usage = usage
273 self.usage = usage
274
274
275 #-------------------------------------------------------------------------
275 #-------------------------------------------------------------------------
276 # Mainloop and code execution logic
276 # Mainloop and code execution logic
277 #-------------------------------------------------------------------------
277 #-------------------------------------------------------------------------
278
278
279 def mainloop(self, display_banner=None):
279 def mainloop(self, display_banner=None):
280 """Start the mainloop.
280 """Start the mainloop.
281
281
282 If an optional banner argument is given, it will override the
282 If an optional banner argument is given, it will override the
283 internally created default banner.
283 internally created default banner.
284 """
284 """
285
285
286 with nested(self.builtin_trap, self.display_trap):
286 with nested(self.builtin_trap, self.display_trap):
287
287
288 while 1:
288 while 1:
289 try:
289 try:
290 self.interact(display_banner=display_banner)
290 self.interact(display_banner=display_banner)
291 #self.interact_with_readline()
291 #self.interact_with_readline()
292 # XXX for testing of a readline-decoupled repl loop, call
292 # XXX for testing of a readline-decoupled repl loop, call
293 # interact_with_readline above
293 # interact_with_readline above
294 break
294 break
295 except KeyboardInterrupt:
295 except KeyboardInterrupt:
296 # this should not be necessary, but KeyboardInterrupt
296 # this should not be necessary, but KeyboardInterrupt
297 # handling seems rather unpredictable...
297 # handling seems rather unpredictable...
298 self.write("\nKeyboardInterrupt in interact()\n")
298 self.write("\nKeyboardInterrupt in interact()\n")
299
299
300 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
300 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
301 """Store multiple lines as a single entry in history"""
301 """Store multiple lines as a single entry in history"""
302
302
303 # do nothing without readline or disabled multiline
303 # do nothing without readline or disabled multiline
304 if not self.has_readline or not self.multiline_history:
304 if not self.has_readline or not self.multiline_history:
305 return hlen_before_cell
305 return hlen_before_cell
306
306
307 # windows rl has no remove_history_item
307 # windows rl has no remove_history_item
308 if not hasattr(self.readline, "remove_history_item"):
308 if not hasattr(self.readline, "remove_history_item"):
309 return hlen_before_cell
309 return hlen_before_cell
310
310
311 # skip empty cells
311 # skip empty cells
312 if not source_raw.rstrip():
312 if not source_raw.rstrip():
313 return hlen_before_cell
313 return hlen_before_cell
314
314
315 # nothing changed do nothing, e.g. when rl removes consecutive dups
315 # nothing changed do nothing, e.g. when rl removes consecutive dups
316 hlen = self.readline.get_current_history_length()
316 hlen = self.readline.get_current_history_length()
317 if hlen == hlen_before_cell:
317 if hlen == hlen_before_cell:
318 return hlen_before_cell
318 return hlen_before_cell
319
319
320 for i in range(hlen - hlen_before_cell):
320 for i in range(hlen - hlen_before_cell):
321 self.readline.remove_history_item(hlen - i - 1)
321 self.readline.remove_history_item(hlen - i - 1)
322 stdin_encoding = sys.stdin.encoding or "utf-8"
322 stdin_encoding = sys.stdin.encoding or "utf-8"
323 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
323 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
324 stdin_encoding))
324 stdin_encoding))
325 return self.readline.get_current_history_length()
325 return self.readline.get_current_history_length()
326
326
327 def interact(self, display_banner=None):
327 def interact(self, display_banner=None):
328 """Closely emulate the interactive Python console."""
328 """Closely emulate the interactive Python console."""
329
329
330 # batch run -> do not interact
330 # batch run -> do not interact
331 if self.exit_now:
331 if self.exit_now:
332 return
332 return
333
333
334 if display_banner is None:
334 if display_banner is None:
335 display_banner = self.display_banner
335 display_banner = self.display_banner
336
336
337 if isinstance(display_banner, basestring):
337 if isinstance(display_banner, basestring):
338 self.show_banner(display_banner)
338 self.show_banner(display_banner)
339 elif display_banner:
339 elif display_banner:
340 self.show_banner()
340 self.show_banner()
341
341
342 more = False
342 more = False
343
343
344 if self.has_readline:
344 if self.has_readline:
345 self.readline_startup_hook(self.pre_readline)
345 self.readline_startup_hook(self.pre_readline)
346 hlen_b4_cell = self.readline.get_current_history_length()
346 hlen_b4_cell = self.readline.get_current_history_length()
347 else:
347 else:
348 hlen_b4_cell = 0
348 hlen_b4_cell = 0
349 # exit_now is set by a call to %Exit or %Quit, through the
349 # exit_now is set by a call to %Exit or %Quit, through the
350 # ask_exit callback.
350 # ask_exit callback.
351
351
352 while not self.exit_now:
352 while not self.exit_now:
353 self.hooks.pre_prompt_hook()
353 self.hooks.pre_prompt_hook()
354 if more:
354 if more:
355 try:
355 try:
356 prompt = self.prompt_manager.render('in2')
356 prompt = self.prompt_manager.render('in2')
357 except:
357 except:
358 self.showtraceback()
358 self.showtraceback()
359 if self.autoindent:
359 if self.autoindent:
360 self.rl_do_indent = True
360 self.rl_do_indent = True
361
361
362 else:
362 else:
363 try:
363 try:
364 prompt = self.separate_in + self.prompt_manager.render('in')
364 prompt = self.separate_in + self.prompt_manager.render('in')
365 except:
365 except:
366 self.showtraceback()
366 self.showtraceback()
367 try:
367 try:
368 line = self.raw_input(prompt)
368 line = self.raw_input(prompt)
369 if self.exit_now:
369 if self.exit_now:
370 # quick exit on sys.std[in|out] close
370 # quick exit on sys.std[in|out] close
371 break
371 break
372 if self.autoindent:
372 if self.autoindent:
373 self.rl_do_indent = False
373 self.rl_do_indent = False
374
374
375 except KeyboardInterrupt:
375 except KeyboardInterrupt:
376 #double-guard against keyboardinterrupts during kbdint handling
376 #double-guard against keyboardinterrupts during kbdint handling
377 try:
377 try:
378 self.write('\nKeyboardInterrupt\n')
378 self.write('\nKeyboardInterrupt\n')
379 source_raw = self.input_splitter.source_raw_reset()[1]
379 source_raw = self.input_splitter.source_raw_reset()[1]
380 hlen_b4_cell = \
380 hlen_b4_cell = \
381 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
381 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
382 more = False
382 more = False
383 except KeyboardInterrupt:
383 except KeyboardInterrupt:
384 pass
384 pass
385 except EOFError:
385 except EOFError:
386 if self.autoindent:
386 if self.autoindent:
387 self.rl_do_indent = False
387 self.rl_do_indent = False
388 if self.has_readline:
388 if self.has_readline:
389 self.readline_startup_hook(None)
389 self.readline_startup_hook(None)
390 self.write('\n')
390 self.write('\n')
391 self.exit()
391 self.exit()
392 except bdb.BdbQuit:
392 except bdb.BdbQuit:
393 warn('The Python debugger has exited with a BdbQuit exception.\n'
393 warn('The Python debugger has exited with a BdbQuit exception.\n'
394 'Because of how pdb handles the stack, it is impossible\n'
394 'Because of how pdb handles the stack, it is impossible\n'
395 'for IPython to properly format this particular exception.\n'
395 'for IPython to properly format this particular exception.\n'
396 'IPython will resume normal operation.')
396 'IPython will resume normal operation.')
397 except:
397 except:
398 # exceptions here are VERY RARE, but they can be triggered
398 # exceptions here are VERY RARE, but they can be triggered
399 # asynchronously by signal handlers, for example.
399 # asynchronously by signal handlers, for example.
400 self.showtraceback()
400 self.showtraceback()
401 else:
401 else:
402 self.input_splitter.push(line)
402 self.input_splitter.push(line)
403 more = self.input_splitter.push_accepts_more()
403 more = self.input_splitter.push_accepts_more()
404 if (self.SyntaxTB.last_syntax_error and
404 if (self.SyntaxTB.last_syntax_error and
405 self.autoedit_syntax):
405 self.autoedit_syntax):
406 self.edit_syntax_error()
406 self.edit_syntax_error()
407 if not more:
407 if not more:
408 source_raw = self.input_splitter.source_raw_reset()[1]
408 source_raw = self.input_splitter.source_raw_reset()[1]
409 self.run_cell(source_raw, store_history=True)
409 self.run_cell(source_raw, store_history=True)
410 hlen_b4_cell = \
410 hlen_b4_cell = \
411 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
411 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
412
412
413 # Turn off the exit flag, so the mainloop can be restarted if desired
413 # Turn off the exit flag, so the mainloop can be restarted if desired
414 self.exit_now = False
414 self.exit_now = False
415
415
416 def raw_input(self, prompt=''):
416 def raw_input(self, prompt=''):
417 """Write a prompt and read a line.
417 """Write a prompt and read a line.
418
418
419 The returned line does not include the trailing newline.
419 The returned line does not include the trailing newline.
420 When the user enters the EOF key sequence, EOFError is raised.
420 When the user enters the EOF key sequence, EOFError is raised.
421
421
422 Optional inputs:
422 Optional inputs:
423
423
424 - prompt(''): a string to be printed to prompt the user.
424 - prompt(''): a string to be printed to prompt the user.
425
425
426 - continue_prompt(False): whether this line is the first one or a
426 - continue_prompt(False): whether this line is the first one or a
427 continuation in a sequence of inputs.
427 continuation in a sequence of inputs.
428 """
428 """
429 # Code run by the user may have modified the readline completer state.
429 # Code run by the user may have modified the readline completer state.
430 # We must ensure that our completer is back in place.
430 # We must ensure that our completer is back in place.
431
431
432 if self.has_readline:
432 if self.has_readline:
433 self.set_readline_completer()
433 self.set_readline_completer()
434
434
435 try:
435 try:
436 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
436 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
437 except ValueError:
437 except ValueError:
438 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
438 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
439 " or sys.stdout.close()!\nExiting IPython!")
439 " or sys.stdout.close()!\nExiting IPython!")
440 self.ask_exit()
440 self.ask_exit()
441 return ""
441 return ""
442
442
443 # Try to be reasonably smart about not re-indenting pasted input more
443 # Try to be reasonably smart about not re-indenting pasted input more
444 # than necessary. We do this by trimming out the auto-indent initial
444 # than necessary. We do this by trimming out the auto-indent initial
445 # spaces, if the user's actual input started itself with whitespace.
445 # spaces, if the user's actual input started itself with whitespace.
446 if self.autoindent:
446 if self.autoindent:
447 if num_ini_spaces(line) > self.indent_current_nsp:
447 if num_ini_spaces(line) > self.indent_current_nsp:
448 line = line[self.indent_current_nsp:]
448 line = line[self.indent_current_nsp:]
449 self.indent_current_nsp = 0
449 self.indent_current_nsp = 0
450
450
451 return line
451 return line
452
452
453 #-------------------------------------------------------------------------
453 #-------------------------------------------------------------------------
454 # Methods to support auto-editing of SyntaxErrors.
454 # Methods to support auto-editing of SyntaxErrors.
455 #-------------------------------------------------------------------------
455 #-------------------------------------------------------------------------
456
456
457 def edit_syntax_error(self):
457 def edit_syntax_error(self):
458 """The bottom half of the syntax error handler called in the main loop.
458 """The bottom half of the syntax error handler called in the main loop.
459
459
460 Loop until syntax error is fixed or user cancels.
460 Loop until syntax error is fixed or user cancels.
461 """
461 """
462
462
463 while self.SyntaxTB.last_syntax_error:
463 while self.SyntaxTB.last_syntax_error:
464 # copy and clear last_syntax_error
464 # copy and clear last_syntax_error
465 err = self.SyntaxTB.clear_err_state()
465 err = self.SyntaxTB.clear_err_state()
466 if not self._should_recompile(err):
466 if not self._should_recompile(err):
467 return
467 return
468 try:
468 try:
469 # may set last_syntax_error again if a SyntaxError is raised
469 # may set last_syntax_error again if a SyntaxError is raised
470 self.safe_execfile(err.filename,self.user_ns)
470 self.safe_execfile(err.filename,self.user_ns)
471 except:
471 except:
472 self.showtraceback()
472 self.showtraceback()
473 else:
473 else:
474 try:
474 try:
475 f = file(err.filename)
475 f = open(err.filename)
476 try:
476 try:
477 # This should be inside a display_trap block and I
477 # This should be inside a display_trap block and I
478 # think it is.
478 # think it is.
479 sys.displayhook(f.read())
479 sys.displayhook(f.read())
480 finally:
480 finally:
481 f.close()
481 f.close()
482 except:
482 except:
483 self.showtraceback()
483 self.showtraceback()
484
484
485 def _should_recompile(self,e):
485 def _should_recompile(self,e):
486 """Utility routine for edit_syntax_error"""
486 """Utility routine for edit_syntax_error"""
487
487
488 if e.filename in ('<ipython console>','<input>','<string>',
488 if e.filename in ('<ipython console>','<input>','<string>',
489 '<console>','<BackgroundJob compilation>',
489 '<console>','<BackgroundJob compilation>',
490 None):
490 None):
491
491
492 return False
492 return False
493 try:
493 try:
494 if (self.autoedit_syntax and
494 if (self.autoedit_syntax and
495 not self.ask_yes_no('Return to editor to correct syntax error? '
495 not self.ask_yes_no('Return to editor to correct syntax error? '
496 '[Y/n] ','y')):
496 '[Y/n] ','y')):
497 return False
497 return False
498 except EOFError:
498 except EOFError:
499 return False
499 return False
500
500
501 def int0(x):
501 def int0(x):
502 try:
502 try:
503 return int(x)
503 return int(x)
504 except TypeError:
504 except TypeError:
505 return 0
505 return 0
506 # always pass integer line and offset values to editor hook
506 # always pass integer line and offset values to editor hook
507 try:
507 try:
508 self.hooks.fix_error_editor(e.filename,
508 self.hooks.fix_error_editor(e.filename,
509 int0(e.lineno),int0(e.offset),e.msg)
509 int0(e.lineno),int0(e.offset),e.msg)
510 except TryNext:
510 except TryNext:
511 warn('Could not open editor')
511 warn('Could not open editor')
512 return False
512 return False
513 return True
513 return True
514
514
515 #-------------------------------------------------------------------------
515 #-------------------------------------------------------------------------
516 # Things related to exiting
516 # Things related to exiting
517 #-------------------------------------------------------------------------
517 #-------------------------------------------------------------------------
518
518
519 def ask_exit(self):
519 def ask_exit(self):
520 """ Ask the shell to exit. Can be overiden and used as a callback. """
520 """ Ask the shell to exit. Can be overiden and used as a callback. """
521 self.exit_now = True
521 self.exit_now = True
522
522
523 def exit(self):
523 def exit(self):
524 """Handle interactive exit.
524 """Handle interactive exit.
525
525
526 This method calls the ask_exit callback."""
526 This method calls the ask_exit callback."""
527 if self.confirm_exit:
527 if self.confirm_exit:
528 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
528 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
529 self.ask_exit()
529 self.ask_exit()
530 else:
530 else:
531 self.ask_exit()
531 self.ask_exit()
532
532
533 #------------------------------------------------------------------------
533 #------------------------------------------------------------------------
534 # Magic overrides
534 # Magic overrides
535 #------------------------------------------------------------------------
535 #------------------------------------------------------------------------
536 # Once the base class stops inheriting from magic, this code needs to be
536 # Once the base class stops inheriting from magic, this code needs to be
537 # moved into a separate machinery as well. For now, at least isolate here
537 # moved into a separate machinery as well. For now, at least isolate here
538 # the magics which this class needs to implement differently from the base
538 # the magics which this class needs to implement differently from the base
539 # class, or that are unique to it.
539 # class, or that are unique to it.
540
540
541 def magic_autoindent(self, parameter_s = ''):
541 def magic_autoindent(self, parameter_s = ''):
542 """Toggle autoindent on/off (if available)."""
542 """Toggle autoindent on/off (if available)."""
543
543
544 self.shell.set_autoindent()
544 self.shell.set_autoindent()
545 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
545 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
546
546
547 @skip_doctest
547 @skip_doctest
548 def magic_cpaste(self, parameter_s=''):
548 def magic_cpaste(self, parameter_s=''):
549 """Paste & execute a pre-formatted code block from clipboard.
549 """Paste & execute a pre-formatted code block from clipboard.
550
550
551 You must terminate the block with '--' (two minus-signs) or Ctrl-D
551 You must terminate the block with '--' (two minus-signs) or Ctrl-D
552 alone on the line. You can also provide your own sentinel with '%paste
552 alone on the line. You can also provide your own sentinel with '%paste
553 -s %%' ('%%' is the new sentinel for this operation)
553 -s %%' ('%%' is the new sentinel for this operation)
554
554
555 The block is dedented prior to execution to enable execution of method
555 The block is dedented prior to execution to enable execution of method
556 definitions. '>' and '+' characters at the beginning of a line are
556 definitions. '>' and '+' characters at the beginning of a line are
557 ignored, to allow pasting directly from e-mails, diff files and
557 ignored, to allow pasting directly from e-mails, diff files and
558 doctests (the '...' continuation prompt is also stripped). The
558 doctests (the '...' continuation prompt is also stripped). The
559 executed block is also assigned to variable named 'pasted_block' for
559 executed block is also assigned to variable named 'pasted_block' for
560 later editing with '%edit pasted_block'.
560 later editing with '%edit pasted_block'.
561
561
562 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
562 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
563 This assigns the pasted block to variable 'foo' as string, without
563 This assigns the pasted block to variable 'foo' as string, without
564 dedenting or executing it (preceding >>> and + is still stripped)
564 dedenting or executing it (preceding >>> and + is still stripped)
565
565
566 '%cpaste -r' re-executes the block previously entered by cpaste.
566 '%cpaste -r' re-executes the block previously entered by cpaste.
567
567
568 Do not be alarmed by garbled output on Windows (it's a readline bug).
568 Do not be alarmed by garbled output on Windows (it's a readline bug).
569 Just press enter and type -- (and press enter again) and the block
569 Just press enter and type -- (and press enter again) and the block
570 will be what was just pasted.
570 will be what was just pasted.
571
571
572 IPython statements (magics, shell escapes) are not supported (yet).
572 IPython statements (magics, shell escapes) are not supported (yet).
573
573
574 See also
574 See also
575 --------
575 --------
576 paste: automatically pull code from clipboard.
576 paste: automatically pull code from clipboard.
577
577
578 Examples
578 Examples
579 --------
579 --------
580 ::
580 ::
581
581
582 In [8]: %cpaste
582 In [8]: %cpaste
583 Pasting code; enter '--' alone on the line to stop.
583 Pasting code; enter '--' alone on the line to stop.
584 :>>> a = ["world!", "Hello"]
584 :>>> a = ["world!", "Hello"]
585 :>>> print " ".join(sorted(a))
585 :>>> print " ".join(sorted(a))
586 :--
586 :--
587 Hello world!
587 Hello world!
588 """
588 """
589
589
590 opts, name = self.parse_options(parameter_s, 'rs:', mode='string')
590 opts, name = self.parse_options(parameter_s, 'rs:', mode='string')
591 if 'r' in opts:
591 if 'r' in opts:
592 rerun_pasted(self.shell)
592 rerun_pasted(self.shell)
593 return
593 return
594
594
595 sentinel = opts.get('s', '--')
595 sentinel = opts.get('s', '--')
596 block = strip_email_quotes(get_pasted_lines(sentinel))
596 block = strip_email_quotes(get_pasted_lines(sentinel))
597 store_or_execute(self.shell, block, name)
597 store_or_execute(self.shell, block, name)
598
598
599 def magic_paste(self, parameter_s=''):
599 def magic_paste(self, parameter_s=''):
600 """Paste & execute a pre-formatted code block from clipboard.
600 """Paste & execute a pre-formatted code block from clipboard.
601
601
602 The text is pulled directly from the clipboard without user
602 The text is pulled directly from the clipboard without user
603 intervention and printed back on the screen before execution (unless
603 intervention and printed back on the screen before execution (unless
604 the -q flag is given to force quiet mode).
604 the -q flag is given to force quiet mode).
605
605
606 The block is dedented prior to execution to enable execution of method
606 The block is dedented prior to execution to enable execution of method
607 definitions. '>' and '+' characters at the beginning of a line are
607 definitions. '>' and '+' characters at the beginning of a line are
608 ignored, to allow pasting directly from e-mails, diff files and
608 ignored, to allow pasting directly from e-mails, diff files and
609 doctests (the '...' continuation prompt is also stripped). The
609 doctests (the '...' continuation prompt is also stripped). The
610 executed block is also assigned to variable named 'pasted_block' for
610 executed block is also assigned to variable named 'pasted_block' for
611 later editing with '%edit pasted_block'.
611 later editing with '%edit pasted_block'.
612
612
613 You can also pass a variable name as an argument, e.g. '%paste foo'.
613 You can also pass a variable name as an argument, e.g. '%paste foo'.
614 This assigns the pasted block to variable 'foo' as string, without
614 This assigns the pasted block to variable 'foo' as string, without
615 dedenting or executing it (preceding >>> and + is still stripped)
615 dedenting or executing it (preceding >>> and + is still stripped)
616
616
617 Options
617 Options
618 -------
618 -------
619
619
620 -r: re-executes the block previously entered by cpaste.
620 -r: re-executes the block previously entered by cpaste.
621
621
622 -q: quiet mode: do not echo the pasted text back to the terminal.
622 -q: quiet mode: do not echo the pasted text back to the terminal.
623
623
624 IPython statements (magics, shell escapes) are not supported (yet).
624 IPython statements (magics, shell escapes) are not supported (yet).
625
625
626 See also
626 See also
627 --------
627 --------
628 cpaste: manually paste code into terminal until you mark its end.
628 cpaste: manually paste code into terminal until you mark its end.
629 """
629 """
630 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
630 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
631 if 'r' in opts:
631 if 'r' in opts:
632 rerun_pasted(self.shell)
632 rerun_pasted(self.shell)
633 return
633 return
634 try:
634 try:
635 text = self.shell.hooks.clipboard_get()
635 text = self.shell.hooks.clipboard_get()
636 block = strip_email_quotes(text.splitlines())
636 block = strip_email_quotes(text.splitlines())
637 except TryNext as clipboard_exc:
637 except TryNext as clipboard_exc:
638 message = getattr(clipboard_exc, 'args')
638 message = getattr(clipboard_exc, 'args')
639 if message:
639 if message:
640 error(message[0])
640 error(message[0])
641 else:
641 else:
642 error('Could not get text from the clipboard.')
642 error('Could not get text from the clipboard.')
643 return
643 return
644
644
645 # By default, echo back to terminal unless quiet mode is requested
645 # By default, echo back to terminal unless quiet mode is requested
646 if 'q' not in opts:
646 if 'q' not in opts:
647 write = self.shell.write
647 write = self.shell.write
648 write(self.shell.pycolorize(block))
648 write(self.shell.pycolorize(block))
649 if not block.endswith('\n'):
649 if not block.endswith('\n'):
650 write('\n')
650 write('\n')
651 write("## -- End pasted text --\n")
651 write("## -- End pasted text --\n")
652
652
653 store_or_execute(self.shell, block, name)
653 store_or_execute(self.shell, block, name)
654
654
655 # Class-level: add a '%cls' magic only on Windows
655 # Class-level: add a '%cls' magic only on Windows
656 if sys.platform == 'win32':
656 if sys.platform == 'win32':
657 def magic_cls(self, s):
657 def magic_cls(self, s):
658 """Clear screen.
658 """Clear screen.
659 """
659 """
660 os.system("cls")
660 os.system("cls")
661
661
662 def showindentationerror(self):
662 def showindentationerror(self):
663 super(TerminalInteractiveShell, self).showindentationerror()
663 super(TerminalInteractiveShell, self).showindentationerror()
664 print("If you want to paste code into IPython, try the "
664 print("If you want to paste code into IPython, try the "
665 "%paste and %cpaste magic functions.")
665 "%paste and %cpaste magic functions.")
666
666
667
667
668 InteractiveShellABC.register(TerminalInteractiveShell)
668 InteractiveShellABC.register(TerminalInteractiveShell)
@@ -1,306 +1,306 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 Class and program to colorize python source code for ANSI terminals.
3 Class and program to colorize python source code for ANSI terminals.
4
4
5 Based on an HTML code highlighter by Jurgen Hermann found at:
5 Based on an HTML code highlighter by Jurgen Hermann found at:
6 http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
6 http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
7
7
8 Modifications by Fernando Perez (fperez@colorado.edu).
8 Modifications by Fernando Perez (fperez@colorado.edu).
9
9
10 Information on the original HTML highlighter follows:
10 Information on the original HTML highlighter follows:
11
11
12 MoinMoin - Python Source Parser
12 MoinMoin - Python Source Parser
13
13
14 Title: Colorize Python source using the built-in tokenizer
14 Title: Colorize Python source using the built-in tokenizer
15
15
16 Submitter: Jurgen Hermann
16 Submitter: Jurgen Hermann
17 Last Updated:2001/04/06
17 Last Updated:2001/04/06
18
18
19 Version no:1.2
19 Version no:1.2
20
20
21 Description:
21 Description:
22
22
23 This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
23 This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
24 Python source code to HTML markup, rendering comments, keywords,
24 Python source code to HTML markup, rendering comments, keywords,
25 operators, numeric and string literals in different colors.
25 operators, numeric and string literals in different colors.
26
26
27 It shows how to use the built-in keyword, token and tokenize modules to
27 It shows how to use the built-in keyword, token and tokenize modules to
28 scan Python source code and re-emit it with no changes to its original
28 scan Python source code and re-emit it with no changes to its original
29 formatting (which is the hard part).
29 formatting (which is the hard part).
30 """
30 """
31
31
32 __all__ = ['ANSICodeColors','Parser']
32 __all__ = ['ANSICodeColors','Parser']
33
33
34 _scheme_default = 'Linux'
34 _scheme_default = 'Linux'
35
35
36 # Imports
36 # Imports
37 import StringIO
37 import StringIO
38 import keyword
38 import keyword
39 import os
39 import os
40 import optparse
40 import optparse
41 import sys
41 import sys
42 import token
42 import token
43 import tokenize
43 import tokenize
44
44
45 try:
45 try:
46 generate_tokens = tokenize.generate_tokens
46 generate_tokens = tokenize.generate_tokens
47 except AttributeError:
47 except AttributeError:
48 # Python 3. Note that we use the undocumented _tokenize because it expects
48 # Python 3. Note that we use the undocumented _tokenize because it expects
49 # strings, not bytes. See also Python issue #9969.
49 # strings, not bytes. See also Python issue #9969.
50 generate_tokens = tokenize._tokenize
50 generate_tokens = tokenize._tokenize
51
51
52 from IPython.utils.coloransi import *
52 from IPython.utils.coloransi import *
53
53
54 #############################################################################
54 #############################################################################
55 ### Python Source Parser (does Hilighting)
55 ### Python Source Parser (does Hilighting)
56 #############################################################################
56 #############################################################################
57
57
58 _KEYWORD = token.NT_OFFSET + 1
58 _KEYWORD = token.NT_OFFSET + 1
59 _TEXT = token.NT_OFFSET + 2
59 _TEXT = token.NT_OFFSET + 2
60
60
61 #****************************************************************************
61 #****************************************************************************
62 # Builtin color schemes
62 # Builtin color schemes
63
63
64 Colors = TermColors # just a shorthand
64 Colors = TermColors # just a shorthand
65
65
66 # Build a few color schemes
66 # Build a few color schemes
67 NoColor = ColorScheme(
67 NoColor = ColorScheme(
68 'NoColor',{
68 'NoColor',{
69 token.NUMBER : Colors.NoColor,
69 token.NUMBER : Colors.NoColor,
70 token.OP : Colors.NoColor,
70 token.OP : Colors.NoColor,
71 token.STRING : Colors.NoColor,
71 token.STRING : Colors.NoColor,
72 tokenize.COMMENT : Colors.NoColor,
72 tokenize.COMMENT : Colors.NoColor,
73 token.NAME : Colors.NoColor,
73 token.NAME : Colors.NoColor,
74 token.ERRORTOKEN : Colors.NoColor,
74 token.ERRORTOKEN : Colors.NoColor,
75
75
76 _KEYWORD : Colors.NoColor,
76 _KEYWORD : Colors.NoColor,
77 _TEXT : Colors.NoColor,
77 _TEXT : Colors.NoColor,
78
78
79 'normal' : Colors.NoColor # color off (usu. Colors.Normal)
79 'normal' : Colors.NoColor # color off (usu. Colors.Normal)
80 } )
80 } )
81
81
82 LinuxColors = ColorScheme(
82 LinuxColors = ColorScheme(
83 'Linux',{
83 'Linux',{
84 token.NUMBER : Colors.LightCyan,
84 token.NUMBER : Colors.LightCyan,
85 token.OP : Colors.Yellow,
85 token.OP : Colors.Yellow,
86 token.STRING : Colors.LightBlue,
86 token.STRING : Colors.LightBlue,
87 tokenize.COMMENT : Colors.LightRed,
87 tokenize.COMMENT : Colors.LightRed,
88 token.NAME : Colors.Normal,
88 token.NAME : Colors.Normal,
89 token.ERRORTOKEN : Colors.Red,
89 token.ERRORTOKEN : Colors.Red,
90
90
91 _KEYWORD : Colors.LightGreen,
91 _KEYWORD : Colors.LightGreen,
92 _TEXT : Colors.Yellow,
92 _TEXT : Colors.Yellow,
93
93
94 'normal' : Colors.Normal # color off (usu. Colors.Normal)
94 'normal' : Colors.Normal # color off (usu. Colors.Normal)
95 } )
95 } )
96
96
97 LightBGColors = ColorScheme(
97 LightBGColors = ColorScheme(
98 'LightBG',{
98 'LightBG',{
99 token.NUMBER : Colors.Cyan,
99 token.NUMBER : Colors.Cyan,
100 token.OP : Colors.Blue,
100 token.OP : Colors.Blue,
101 token.STRING : Colors.Blue,
101 token.STRING : Colors.Blue,
102 tokenize.COMMENT : Colors.Red,
102 tokenize.COMMENT : Colors.Red,
103 token.NAME : Colors.Normal,
103 token.NAME : Colors.Normal,
104 token.ERRORTOKEN : Colors.Red,
104 token.ERRORTOKEN : Colors.Red,
105
105
106 _KEYWORD : Colors.Green,
106 _KEYWORD : Colors.Green,
107 _TEXT : Colors.Blue,
107 _TEXT : Colors.Blue,
108
108
109 'normal' : Colors.Normal # color off (usu. Colors.Normal)
109 'normal' : Colors.Normal # color off (usu. Colors.Normal)
110 } )
110 } )
111
111
112 # Build table of color schemes (needed by the parser)
112 # Build table of color schemes (needed by the parser)
113 ANSICodeColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
113 ANSICodeColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
114 _scheme_default)
114 _scheme_default)
115
115
116 class Parser:
116 class Parser:
117 """ Format colored Python source.
117 """ Format colored Python source.
118 """
118 """
119
119
120 def __init__(self, color_table=None,out = sys.stdout):
120 def __init__(self, color_table=None,out = sys.stdout):
121 """ Create a parser with a specified color table and output channel.
121 """ Create a parser with a specified color table and output channel.
122
122
123 Call format() to process code.
123 Call format() to process code.
124 """
124 """
125 self.color_table = color_table and color_table or ANSICodeColors
125 self.color_table = color_table and color_table or ANSICodeColors
126 self.out = out
126 self.out = out
127
127
128 def format(self, raw, out = None, scheme = ''):
128 def format(self, raw, out = None, scheme = ''):
129 return self.format2(raw, out, scheme)[0]
129 return self.format2(raw, out, scheme)[0]
130
130
131 def format2(self, raw, out = None, scheme = ''):
131 def format2(self, raw, out = None, scheme = ''):
132 """ Parse and send the colored source.
132 """ Parse and send the colored source.
133
133
134 If out and scheme are not specified, the defaults (given to
134 If out and scheme are not specified, the defaults (given to
135 constructor) are used.
135 constructor) are used.
136
136
137 out should be a file-type object. Optionally, out can be given as the
137 out should be a file-type object. Optionally, out can be given as the
138 string 'str' and the parser will automatically return the output in a
138 string 'str' and the parser will automatically return the output in a
139 string."""
139 string."""
140
140
141 string_output = 0
141 string_output = 0
142 if out == 'str' or self.out == 'str' or \
142 if out == 'str' or self.out == 'str' or \
143 isinstance(self.out,StringIO.StringIO):
143 isinstance(self.out,StringIO.StringIO):
144 # XXX - I don't really like this state handling logic, but at this
144 # XXX - I don't really like this state handling logic, but at this
145 # point I don't want to make major changes, so adding the
145 # point I don't want to make major changes, so adding the
146 # isinstance() check is the simplest I can do to ensure correct
146 # isinstance() check is the simplest I can do to ensure correct
147 # behavior.
147 # behavior.
148 out_old = self.out
148 out_old = self.out
149 self.out = StringIO.StringIO()
149 self.out = StringIO.StringIO()
150 string_output = 1
150 string_output = 1
151 elif out is not None:
151 elif out is not None:
152 self.out = out
152 self.out = out
153
153
154 # Fast return of the unmodified input for NoColor scheme
154 # Fast return of the unmodified input for NoColor scheme
155 if scheme == 'NoColor':
155 if scheme == 'NoColor':
156 error = False
156 error = False
157 self.out.write(raw)
157 self.out.write(raw)
158 if string_output:
158 if string_output:
159 return raw,error
159 return raw,error
160 else:
160 else:
161 return None,error
161 return None,error
162
162
163 # local shorthands
163 # local shorthands
164 colors = self.color_table[scheme].colors
164 colors = self.color_table[scheme].colors
165 self.colors = colors # put in object so __call__ sees it
165 self.colors = colors # put in object so __call__ sees it
166
166
167 # Remove trailing whitespace and normalize tabs
167 # Remove trailing whitespace and normalize tabs
168 self.raw = raw.expandtabs().rstrip()
168 self.raw = raw.expandtabs().rstrip()
169
169
170 # store line offsets in self.lines
170 # store line offsets in self.lines
171 self.lines = [0, 0]
171 self.lines = [0, 0]
172 pos = 0
172 pos = 0
173 raw_find = self.raw.find
173 raw_find = self.raw.find
174 lines_append = self.lines.append
174 lines_append = self.lines.append
175 while 1:
175 while 1:
176 pos = raw_find('\n', pos) + 1
176 pos = raw_find('\n', pos) + 1
177 if not pos: break
177 if not pos: break
178 lines_append(pos)
178 lines_append(pos)
179 lines_append(len(self.raw))
179 lines_append(len(self.raw))
180
180
181 # parse the source and write it
181 # parse the source and write it
182 self.pos = 0
182 self.pos = 0
183 text = StringIO.StringIO(self.raw)
183 text = StringIO.StringIO(self.raw)
184
184
185 error = False
185 error = False
186 try:
186 try:
187 for atoken in generate_tokens(text.readline):
187 for atoken in generate_tokens(text.readline):
188 self(*atoken)
188 self(*atoken)
189 except tokenize.TokenError as ex:
189 except tokenize.TokenError as ex:
190 msg = ex.args[0]
190 msg = ex.args[0]
191 line = ex.args[1][0]
191 line = ex.args[1][0]
192 self.out.write("%s\n\n*** ERROR: %s%s%s\n" %
192 self.out.write("%s\n\n*** ERROR: %s%s%s\n" %
193 (colors[token.ERRORTOKEN],
193 (colors[token.ERRORTOKEN],
194 msg, self.raw[self.lines[line]:],
194 msg, self.raw[self.lines[line]:],
195 colors.normal)
195 colors.normal)
196 )
196 )
197 error = True
197 error = True
198 self.out.write(colors.normal+'\n')
198 self.out.write(colors.normal+'\n')
199 if string_output:
199 if string_output:
200 output = self.out.getvalue()
200 output = self.out.getvalue()
201 self.out = out_old
201 self.out = out_old
202 return (output, error)
202 return (output, error)
203 return (None, error)
203 return (None, error)
204
204
205 def __call__(self, toktype, toktext, (srow,scol), (erow,ecol), line):
205 def __call__(self, toktype, toktext, (srow,scol), (erow,ecol), line):
206 """ Token handler, with syntax highlighting."""
206 """ Token handler, with syntax highlighting."""
207
207
208 # local shorthands
208 # local shorthands
209 colors = self.colors
209 colors = self.colors
210 owrite = self.out.write
210 owrite = self.out.write
211
211
212 # line separator, so this works across platforms
212 # line separator, so this works across platforms
213 linesep = os.linesep
213 linesep = os.linesep
214
214
215 # calculate new positions
215 # calculate new positions
216 oldpos = self.pos
216 oldpos = self.pos
217 newpos = self.lines[srow] + scol
217 newpos = self.lines[srow] + scol
218 self.pos = newpos + len(toktext)
218 self.pos = newpos + len(toktext)
219
219
220 # send the original whitespace, if needed
220 # send the original whitespace, if needed
221 if newpos > oldpos:
221 if newpos > oldpos:
222 owrite(self.raw[oldpos:newpos])
222 owrite(self.raw[oldpos:newpos])
223
223
224 # skip indenting tokens
224 # skip indenting tokens
225 if toktype in [token.INDENT, token.DEDENT]:
225 if toktype in [token.INDENT, token.DEDENT]:
226 self.pos = newpos
226 self.pos = newpos
227 return
227 return
228
228
229 # map token type to a color group
229 # map token type to a color group
230 if token.LPAR <= toktype and toktype <= token.OP:
230 if token.LPAR <= toktype and toktype <= token.OP:
231 toktype = token.OP
231 toktype = token.OP
232 elif toktype == token.NAME and keyword.iskeyword(toktext):
232 elif toktype == token.NAME and keyword.iskeyword(toktext):
233 toktype = _KEYWORD
233 toktype = _KEYWORD
234 color = colors.get(toktype, colors[_TEXT])
234 color = colors.get(toktype, colors[_TEXT])
235
235
236 #print '<%s>' % toktext, # dbg
236 #print '<%s>' % toktext, # dbg
237
237
238 # Triple quoted strings must be handled carefully so that backtracking
238 # Triple quoted strings must be handled carefully so that backtracking
239 # in pagers works correctly. We need color terminators on _each_ line.
239 # in pagers works correctly. We need color terminators on _each_ line.
240 if linesep in toktext:
240 if linesep in toktext:
241 toktext = toktext.replace(linesep, '%s%s%s' %
241 toktext = toktext.replace(linesep, '%s%s%s' %
242 (colors.normal,linesep,color))
242 (colors.normal,linesep,color))
243
243
244 # send text
244 # send text
245 owrite('%s%s%s' % (color,toktext,colors.normal))
245 owrite('%s%s%s' % (color,toktext,colors.normal))
246
246
247 def main(argv=None):
247 def main(argv=None):
248 """Run as a command-line script: colorize a python file or stdin using ANSI
248 """Run as a command-line script: colorize a python file or stdin using ANSI
249 color escapes and print to stdout.
249 color escapes and print to stdout.
250
250
251 Inputs:
251 Inputs:
252
252
253 - argv(None): a list of strings like sys.argv[1:] giving the command-line
253 - argv(None): a list of strings like sys.argv[1:] giving the command-line
254 arguments. If None, use sys.argv[1:].
254 arguments. If None, use sys.argv[1:].
255 """
255 """
256
256
257 usage_msg = """%prog [options] [filename]
257 usage_msg = """%prog [options] [filename]
258
258
259 Colorize a python file or stdin using ANSI color escapes and print to stdout.
259 Colorize a python file or stdin using ANSI color escapes and print to stdout.
260 If no filename is given, or if filename is -, read standard input."""
260 If no filename is given, or if filename is -, read standard input."""
261
261
262 parser = optparse.OptionParser(usage=usage_msg)
262 parser = optparse.OptionParser(usage=usage_msg)
263 newopt = parser.add_option
263 newopt = parser.add_option
264 newopt('-s','--scheme',metavar='NAME',dest='scheme_name',action='store',
264 newopt('-s','--scheme',metavar='NAME',dest='scheme_name',action='store',
265 choices=['Linux','LightBG','NoColor'],default=_scheme_default,
265 choices=['Linux','LightBG','NoColor'],default=_scheme_default,
266 help="give the color scheme to use. Currently only 'Linux'\
266 help="give the color scheme to use. Currently only 'Linux'\
267 (default) and 'LightBG' and 'NoColor' are implemented (give without\
267 (default) and 'LightBG' and 'NoColor' are implemented (give without\
268 quotes)")
268 quotes)")
269
269
270 opts,args = parser.parse_args(argv)
270 opts,args = parser.parse_args(argv)
271
271
272 if len(args) > 1:
272 if len(args) > 1:
273 parser.error("you must give at most one filename.")
273 parser.error("you must give at most one filename.")
274
274
275 if len(args) == 0:
275 if len(args) == 0:
276 fname = '-' # no filename given; setup to read from stdin
276 fname = '-' # no filename given; setup to read from stdin
277 else:
277 else:
278 fname = args[0]
278 fname = args[0]
279
279
280 if fname == '-':
280 if fname == '-':
281 stream = sys.stdin
281 stream = sys.stdin
282 else:
282 else:
283 try:
283 try:
284 stream = file(fname)
284 stream = open(fname)
285 except IOError,msg:
285 except IOError,msg:
286 print >> sys.stderr, msg
286 print >> sys.stderr, msg
287 sys.exit(1)
287 sys.exit(1)
288
288
289 parser = Parser()
289 parser = Parser()
290
290
291 # we need nested try blocks because pre-2.5 python doesn't support unified
291 # we need nested try blocks because pre-2.5 python doesn't support unified
292 # try-except-finally
292 # try-except-finally
293 try:
293 try:
294 try:
294 try:
295 # write colorized version to stdout
295 # write colorized version to stdout
296 parser.format(stream.read(),scheme=opts.scheme_name)
296 parser.format(stream.read(),scheme=opts.scheme_name)
297 except IOError,msg:
297 except IOError,msg:
298 # if user reads through a pager and quits, don't print traceback
298 # if user reads through a pager and quits, don't print traceback
299 if msg.args != (32,'Broken pipe'):
299 if msg.args != (32,'Broken pipe'):
300 raise
300 raise
301 finally:
301 finally:
302 if stream is not sys.stdin:
302 if stream is not sys.stdin:
303 stream.close() # in case a non-handled exception happened above
303 stream.close() # in case a non-handled exception happened above
304
304
305 if __name__ == "__main__":
305 if __name__ == "__main__":
306 main()
306 main()
@@ -1,306 +1,306 b''
1 """An Application for launching a kernel
1 """An Application for launching a kernel
2
2
3 Authors
3 Authors
4 -------
4 -------
5 * MinRK
5 * MinRK
6 """
6 """
7 #-----------------------------------------------------------------------------
7 #-----------------------------------------------------------------------------
8 # Copyright (C) 2011 The IPython Development Team
8 # Copyright (C) 2011 The IPython Development Team
9 #
9 #
10 # Distributed under the terms of the BSD License. The full license is in
10 # Distributed under the terms of the BSD License. The full license is in
11 # the file COPYING.txt, distributed as part of this software.
11 # the file COPYING.txt, distributed as part of this software.
12 #-----------------------------------------------------------------------------
12 #-----------------------------------------------------------------------------
13
13
14 #-----------------------------------------------------------------------------
14 #-----------------------------------------------------------------------------
15 # Imports
15 # Imports
16 #-----------------------------------------------------------------------------
16 #-----------------------------------------------------------------------------
17
17
18 # Standard library imports.
18 # Standard library imports.
19 import json
19 import json
20 import os
20 import os
21 import sys
21 import sys
22
22
23 # System library imports.
23 # System library imports.
24 import zmq
24 import zmq
25
25
26 # IPython imports.
26 # IPython imports.
27 from IPython.core.ultratb import FormattedTB
27 from IPython.core.ultratb import FormattedTB
28 from IPython.core.application import (
28 from IPython.core.application import (
29 BaseIPythonApplication, base_flags, base_aliases, catch_config_error
29 BaseIPythonApplication, base_flags, base_aliases, catch_config_error
30 )
30 )
31 from IPython.utils import io
31 from IPython.utils import io
32 from IPython.utils.localinterfaces import LOCALHOST
32 from IPython.utils.localinterfaces import LOCALHOST
33 from IPython.utils.path import filefind
33 from IPython.utils.path import filefind
34 from IPython.utils.py3compat import str_to_bytes
34 from IPython.utils.py3compat import str_to_bytes
35 from IPython.utils.traitlets import (Any, Instance, Dict, Unicode, Integer, Bool,
35 from IPython.utils.traitlets import (Any, Instance, Dict, Unicode, Integer, Bool,
36 DottedObjectName)
36 DottedObjectName)
37 from IPython.utils.importstring import import_item
37 from IPython.utils.importstring import import_item
38 # local imports
38 # local imports
39 from IPython.zmq.entry_point import write_connection_file
39 from IPython.zmq.entry_point import write_connection_file
40 from IPython.zmq.heartbeat import Heartbeat
40 from IPython.zmq.heartbeat import Heartbeat
41 from IPython.zmq.parentpoller import ParentPollerUnix, ParentPollerWindows
41 from IPython.zmq.parentpoller import ParentPollerUnix, ParentPollerWindows
42 from IPython.zmq.session import (
42 from IPython.zmq.session import (
43 Session, session_flags, session_aliases, default_secure,
43 Session, session_flags, session_aliases, default_secure,
44 )
44 )
45
45
46
46
47 #-----------------------------------------------------------------------------
47 #-----------------------------------------------------------------------------
48 # Flags and Aliases
48 # Flags and Aliases
49 #-----------------------------------------------------------------------------
49 #-----------------------------------------------------------------------------
50
50
51 kernel_aliases = dict(base_aliases)
51 kernel_aliases = dict(base_aliases)
52 kernel_aliases.update({
52 kernel_aliases.update({
53 'ip' : 'KernelApp.ip',
53 'ip' : 'KernelApp.ip',
54 'hb' : 'KernelApp.hb_port',
54 'hb' : 'KernelApp.hb_port',
55 'shell' : 'KernelApp.shell_port',
55 'shell' : 'KernelApp.shell_port',
56 'iopub' : 'KernelApp.iopub_port',
56 'iopub' : 'KernelApp.iopub_port',
57 'stdin' : 'KernelApp.stdin_port',
57 'stdin' : 'KernelApp.stdin_port',
58 'f' : 'KernelApp.connection_file',
58 'f' : 'KernelApp.connection_file',
59 'parent': 'KernelApp.parent',
59 'parent': 'KernelApp.parent',
60 })
60 })
61 if sys.platform.startswith('win'):
61 if sys.platform.startswith('win'):
62 kernel_aliases['interrupt'] = 'KernelApp.interrupt'
62 kernel_aliases['interrupt'] = 'KernelApp.interrupt'
63
63
64 kernel_flags = dict(base_flags)
64 kernel_flags = dict(base_flags)
65 kernel_flags.update({
65 kernel_flags.update({
66 'no-stdout' : (
66 'no-stdout' : (
67 {'KernelApp' : {'no_stdout' : True}},
67 {'KernelApp' : {'no_stdout' : True}},
68 "redirect stdout to the null device"),
68 "redirect stdout to the null device"),
69 'no-stderr' : (
69 'no-stderr' : (
70 {'KernelApp' : {'no_stderr' : True}},
70 {'KernelApp' : {'no_stderr' : True}},
71 "redirect stderr to the null device"),
71 "redirect stderr to the null device"),
72 })
72 })
73
73
74 # inherit flags&aliases for Sessions
74 # inherit flags&aliases for Sessions
75 kernel_aliases.update(session_aliases)
75 kernel_aliases.update(session_aliases)
76 kernel_flags.update(session_flags)
76 kernel_flags.update(session_flags)
77
77
78
78
79
79
80 #-----------------------------------------------------------------------------
80 #-----------------------------------------------------------------------------
81 # Application class for starting a Kernel
81 # Application class for starting a Kernel
82 #-----------------------------------------------------------------------------
82 #-----------------------------------------------------------------------------
83
83
84 class KernelApp(BaseIPythonApplication):
84 class KernelApp(BaseIPythonApplication):
85 name='pykernel'
85 name='pykernel'
86 aliases = Dict(kernel_aliases)
86 aliases = Dict(kernel_aliases)
87 flags = Dict(kernel_flags)
87 flags = Dict(kernel_flags)
88 classes = [Session]
88 classes = [Session]
89 # the kernel class, as an importstring
89 # the kernel class, as an importstring
90 kernel_class = DottedObjectName('IPython.zmq.pykernel.Kernel')
90 kernel_class = DottedObjectName('IPython.zmq.pykernel.Kernel')
91 kernel = Any()
91 kernel = Any()
92 poller = Any() # don't restrict this even though current pollers are all Threads
92 poller = Any() # don't restrict this even though current pollers are all Threads
93 heartbeat = Instance(Heartbeat)
93 heartbeat = Instance(Heartbeat)
94 session = Instance('IPython.zmq.session.Session')
94 session = Instance('IPython.zmq.session.Session')
95 ports = Dict()
95 ports = Dict()
96
96
97 # inherit config file name from parent:
97 # inherit config file name from parent:
98 parent_appname = Unicode(config=True)
98 parent_appname = Unicode(config=True)
99 def _parent_appname_changed(self, name, old, new):
99 def _parent_appname_changed(self, name, old, new):
100 if self.config_file_specified:
100 if self.config_file_specified:
101 # it was manually specified, ignore
101 # it was manually specified, ignore
102 return
102 return
103 self.config_file_name = new.replace('-','_') + u'_config.py'
103 self.config_file_name = new.replace('-','_') + u'_config.py'
104 # don't let this count as specifying the config file
104 # don't let this count as specifying the config file
105 self.config_file_specified = False
105 self.config_file_specified = False
106
106
107 # connection info:
107 # connection info:
108 ip = Unicode(LOCALHOST, config=True,
108 ip = Unicode(LOCALHOST, config=True,
109 help="Set the IP or interface on which the kernel will listen.")
109 help="Set the IP or interface on which the kernel will listen.")
110 hb_port = Integer(0, config=True, help="set the heartbeat port [default: random]")
110 hb_port = Integer(0, config=True, help="set the heartbeat port [default: random]")
111 shell_port = Integer(0, config=True, help="set the shell (XREP) port [default: random]")
111 shell_port = Integer(0, config=True, help="set the shell (XREP) port [default: random]")
112 iopub_port = Integer(0, config=True, help="set the iopub (PUB) port [default: random]")
112 iopub_port = Integer(0, config=True, help="set the iopub (PUB) port [default: random]")
113 stdin_port = Integer(0, config=True, help="set the stdin (XREQ) port [default: random]")
113 stdin_port = Integer(0, config=True, help="set the stdin (XREQ) port [default: random]")
114 connection_file = Unicode('', config=True,
114 connection_file = Unicode('', config=True,
115 help="""JSON file in which to store connection info [default: kernel-<pid>.json]
115 help="""JSON file in which to store connection info [default: kernel-<pid>.json]
116
116
117 This file will contain the IP, ports, and authentication key needed to connect
117 This file will contain the IP, ports, and authentication key needed to connect
118 clients to this kernel. By default, this file will be created in the security-dir
118 clients to this kernel. By default, this file will be created in the security-dir
119 of the current profile, but can be specified by absolute path.
119 of the current profile, but can be specified by absolute path.
120 """)
120 """)
121
121
122 # streams, etc.
122 # streams, etc.
123 no_stdout = Bool(False, config=True, help="redirect stdout to the null device")
123 no_stdout = Bool(False, config=True, help="redirect stdout to the null device")
124 no_stderr = Bool(False, config=True, help="redirect stderr to the null device")
124 no_stderr = Bool(False, config=True, help="redirect stderr to the null device")
125 outstream_class = DottedObjectName('IPython.zmq.iostream.OutStream',
125 outstream_class = DottedObjectName('IPython.zmq.iostream.OutStream',
126 config=True, help="The importstring for the OutStream factory")
126 config=True, help="The importstring for the OutStream factory")
127 displayhook_class = DottedObjectName('IPython.zmq.displayhook.ZMQDisplayHook',
127 displayhook_class = DottedObjectName('IPython.zmq.displayhook.ZMQDisplayHook',
128 config=True, help="The importstring for the DisplayHook factory")
128 config=True, help="The importstring for the DisplayHook factory")
129
129
130 # polling
130 # polling
131 parent = Integer(0, config=True,
131 parent = Integer(0, config=True,
132 help="""kill this process if its parent dies. On Windows, the argument
132 help="""kill this process if its parent dies. On Windows, the argument
133 specifies the HANDLE of the parent process, otherwise it is simply boolean.
133 specifies the HANDLE of the parent process, otherwise it is simply boolean.
134 """)
134 """)
135 interrupt = Integer(0, config=True,
135 interrupt = Integer(0, config=True,
136 help="""ONLY USED ON WINDOWS
136 help="""ONLY USED ON WINDOWS
137 Interrupt this process when the parent is signalled.
137 Interrupt this process when the parent is signalled.
138 """)
138 """)
139
139
140 def init_crash_handler(self):
140 def init_crash_handler(self):
141 # Install minimal exception handling
141 # Install minimal exception handling
142 sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor',
142 sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor',
143 ostream=sys.__stdout__)
143 ostream=sys.__stdout__)
144
144
145 def init_poller(self):
145 def init_poller(self):
146 if sys.platform == 'win32':
146 if sys.platform == 'win32':
147 if self.interrupt or self.parent:
147 if self.interrupt or self.parent:
148 self.poller = ParentPollerWindows(self.interrupt, self.parent)
148 self.poller = ParentPollerWindows(self.interrupt, self.parent)
149 elif self.parent:
149 elif self.parent:
150 self.poller = ParentPollerUnix()
150 self.poller = ParentPollerUnix()
151
151
152 def _bind_socket(self, s, port):
152 def _bind_socket(self, s, port):
153 iface = 'tcp://%s' % self.ip
153 iface = 'tcp://%s' % self.ip
154 if port <= 0:
154 if port <= 0:
155 port = s.bind_to_random_port(iface)
155 port = s.bind_to_random_port(iface)
156 else:
156 else:
157 s.bind(iface + ':%i'%port)
157 s.bind(iface + ':%i'%port)
158 return port
158 return port
159
159
160 def load_connection_file(self):
160 def load_connection_file(self):
161 """load ip/port/hmac config from JSON connection file"""
161 """load ip/port/hmac config from JSON connection file"""
162 try:
162 try:
163 fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
163 fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
164 except IOError:
164 except IOError:
165 self.log.debug("Connection file not found: %s", self.connection_file)
165 self.log.debug("Connection file not found: %s", self.connection_file)
166 return
166 return
167 self.log.debug(u"Loading connection file %s", fname)
167 self.log.debug(u"Loading connection file %s", fname)
168 with open(fname) as f:
168 with open(fname) as f:
169 s = f.read()
169 s = f.read()
170 cfg = json.loads(s)
170 cfg = json.loads(s)
171 if self.ip == LOCALHOST and 'ip' in cfg:
171 if self.ip == LOCALHOST and 'ip' in cfg:
172 # not overridden by config or cl_args
172 # not overridden by config or cl_args
173 self.ip = cfg['ip']
173 self.ip = cfg['ip']
174 for channel in ('hb', 'shell', 'iopub', 'stdin'):
174 for channel in ('hb', 'shell', 'iopub', 'stdin'):
175 name = channel + '_port'
175 name = channel + '_port'
176 if getattr(self, name) == 0 and name in cfg:
176 if getattr(self, name) == 0 and name in cfg:
177 # not overridden by config or cl_args
177 # not overridden by config or cl_args
178 setattr(self, name, cfg[name])
178 setattr(self, name, cfg[name])
179 if 'key' in cfg:
179 if 'key' in cfg:
180 self.config.Session.key = str_to_bytes(cfg['key'])
180 self.config.Session.key = str_to_bytes(cfg['key'])
181
181
182 def write_connection_file(self):
182 def write_connection_file(self):
183 """write connection info to JSON file"""
183 """write connection info to JSON file"""
184 if os.path.basename(self.connection_file) == self.connection_file:
184 if os.path.basename(self.connection_file) == self.connection_file:
185 cf = os.path.join(self.profile_dir.security_dir, self.connection_file)
185 cf = os.path.join(self.profile_dir.security_dir, self.connection_file)
186 else:
186 else:
187 cf = self.connection_file
187 cf = self.connection_file
188 write_connection_file(cf, ip=self.ip, key=self.session.key,
188 write_connection_file(cf, ip=self.ip, key=self.session.key,
189 shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port,
189 shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port,
190 iopub_port=self.iopub_port)
190 iopub_port=self.iopub_port)
191
191
192 def init_connection_file(self):
192 def init_connection_file(self):
193 if not self.connection_file:
193 if not self.connection_file:
194 self.connection_file = "kernel-%s.json"%os.getpid()
194 self.connection_file = "kernel-%s.json"%os.getpid()
195 try:
195 try:
196 self.load_connection_file()
196 self.load_connection_file()
197 except Exception:
197 except Exception:
198 self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
198 self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
199 self.exit(1)
199 self.exit(1)
200
200
201 def init_sockets(self):
201 def init_sockets(self):
202 # Create a context, a session, and the kernel sockets.
202 # Create a context, a session, and the kernel sockets.
203 self.log.info("Starting the kernel at pid: %i", os.getpid())
203 self.log.info("Starting the kernel at pid: %i", os.getpid())
204 context = zmq.Context.instance()
204 context = zmq.Context.instance()
205 # Uncomment this to try closing the context.
205 # Uncomment this to try closing the context.
206 # atexit.register(context.term)
206 # atexit.register(context.term)
207
207
208 self.shell_socket = context.socket(zmq.ROUTER)
208 self.shell_socket = context.socket(zmq.ROUTER)
209 self.shell_port = self._bind_socket(self.shell_socket, self.shell_port)
209 self.shell_port = self._bind_socket(self.shell_socket, self.shell_port)
210 self.log.debug("shell ROUTER Channel on port: %i"%self.shell_port)
210 self.log.debug("shell ROUTER Channel on port: %i"%self.shell_port)
211
211
212 self.iopub_socket = context.socket(zmq.PUB)
212 self.iopub_socket = context.socket(zmq.PUB)
213 self.iopub_port = self._bind_socket(self.iopub_socket, self.iopub_port)
213 self.iopub_port = self._bind_socket(self.iopub_socket, self.iopub_port)
214 self.log.debug("iopub PUB Channel on port: %i"%self.iopub_port)
214 self.log.debug("iopub PUB Channel on port: %i"%self.iopub_port)
215
215
216 self.stdin_socket = context.socket(zmq.ROUTER)
216 self.stdin_socket = context.socket(zmq.ROUTER)
217 self.stdin_port = self._bind_socket(self.stdin_socket, self.stdin_port)
217 self.stdin_port = self._bind_socket(self.stdin_socket, self.stdin_port)
218 self.log.debug("stdin ROUTER Channel on port: %i"%self.stdin_port)
218 self.log.debug("stdin ROUTER Channel on port: %i"%self.stdin_port)
219
219
220 # heartbeat doesn't share context, because it mustn't be blocked
220 # heartbeat doesn't share context, because it mustn't be blocked
221 # by the GIL, which is accessed by libzmq when freeing zero-copy messages
221 # by the GIL, which is accessed by libzmq when freeing zero-copy messages
222 hb_ctx = zmq.Context()
222 hb_ctx = zmq.Context()
223 self.heartbeat = Heartbeat(hb_ctx, (self.ip, self.hb_port))
223 self.heartbeat = Heartbeat(hb_ctx, (self.ip, self.hb_port))
224 self.hb_port = self.heartbeat.port
224 self.hb_port = self.heartbeat.port
225 self.log.debug("Heartbeat REP Channel on port: %i"%self.hb_port)
225 self.log.debug("Heartbeat REP Channel on port: %i"%self.hb_port)
226
226
227 # Helper to make it easier to connect to an existing kernel.
227 # Helper to make it easier to connect to an existing kernel.
228 # set log-level to critical, to make sure it is output
228 # set log-level to critical, to make sure it is output
229 self.log.critical("To connect another client to this kernel, use:")
229 self.log.critical("To connect another client to this kernel, use:")
230
230
231 basename = os.path.basename(self.connection_file)
231 basename = os.path.basename(self.connection_file)
232 if basename == self.connection_file or \
232 if basename == self.connection_file or \
233 os.path.dirname(self.connection_file) == self.profile_dir.security_dir:
233 os.path.dirname(self.connection_file) == self.profile_dir.security_dir:
234 # use shortname
234 # use shortname
235 tail = basename
235 tail = basename
236 if self.profile != 'default':
236 if self.profile != 'default':
237 tail += " --profile %s" % self.profile
237 tail += " --profile %s" % self.profile
238 else:
238 else:
239 tail = self.connection_file
239 tail = self.connection_file
240 self.log.critical("--existing %s", tail)
240 self.log.critical("--existing %s", tail)
241
241
242
242
243 self.ports = dict(shell=self.shell_port, iopub=self.iopub_port,
243 self.ports = dict(shell=self.shell_port, iopub=self.iopub_port,
244 stdin=self.stdin_port, hb=self.hb_port)
244 stdin=self.stdin_port, hb=self.hb_port)
245
245
246 def init_session(self):
246 def init_session(self):
247 """create our session object"""
247 """create our session object"""
248 default_secure(self.config)
248 default_secure(self.config)
249 self.session = Session(config=self.config, username=u'kernel')
249 self.session = Session(config=self.config, username=u'kernel')
250
250
251 def init_blackhole(self):
251 def init_blackhole(self):
252 """redirects stdout/stderr to devnull if necessary"""
252 """redirects stdout/stderr to devnull if necessary"""
253 if self.no_stdout or self.no_stderr:
253 if self.no_stdout or self.no_stderr:
254 blackhole = file(os.devnull, 'w')
254 blackhole = open(os.devnull, 'w')
255 if self.no_stdout:
255 if self.no_stdout:
256 sys.stdout = sys.__stdout__ = blackhole
256 sys.stdout = sys.__stdout__ = blackhole
257 if self.no_stderr:
257 if self.no_stderr:
258 sys.stderr = sys.__stderr__ = blackhole
258 sys.stderr = sys.__stderr__ = blackhole
259
259
260 def init_io(self):
260 def init_io(self):
261 """Redirect input streams and set a display hook."""
261 """Redirect input streams and set a display hook."""
262 if self.outstream_class:
262 if self.outstream_class:
263 outstream_factory = import_item(str(self.outstream_class))
263 outstream_factory = import_item(str(self.outstream_class))
264 sys.stdout = outstream_factory(self.session, self.iopub_socket, u'stdout')
264 sys.stdout = outstream_factory(self.session, self.iopub_socket, u'stdout')
265 sys.stderr = outstream_factory(self.session, self.iopub_socket, u'stderr')
265 sys.stderr = outstream_factory(self.session, self.iopub_socket, u'stderr')
266 if self.displayhook_class:
266 if self.displayhook_class:
267 displayhook_factory = import_item(str(self.displayhook_class))
267 displayhook_factory = import_item(str(self.displayhook_class))
268 sys.displayhook = displayhook_factory(self.session, self.iopub_socket)
268 sys.displayhook = displayhook_factory(self.session, self.iopub_socket)
269
269
270 def init_kernel(self):
270 def init_kernel(self):
271 """Create the Kernel object itself"""
271 """Create the Kernel object itself"""
272 kernel_factory = import_item(str(self.kernel_class))
272 kernel_factory = import_item(str(self.kernel_class))
273 self.kernel = kernel_factory(config=self.config, session=self.session,
273 self.kernel = kernel_factory(config=self.config, session=self.session,
274 shell_socket=self.shell_socket,
274 shell_socket=self.shell_socket,
275 iopub_socket=self.iopub_socket,
275 iopub_socket=self.iopub_socket,
276 stdin_socket=self.stdin_socket,
276 stdin_socket=self.stdin_socket,
277 log=self.log
277 log=self.log
278 )
278 )
279 self.kernel.record_ports(self.ports)
279 self.kernel.record_ports(self.ports)
280
280
281 @catch_config_error
281 @catch_config_error
282 def initialize(self, argv=None):
282 def initialize(self, argv=None):
283 super(KernelApp, self).initialize(argv)
283 super(KernelApp, self).initialize(argv)
284 self.init_blackhole()
284 self.init_blackhole()
285 self.init_connection_file()
285 self.init_connection_file()
286 self.init_session()
286 self.init_session()
287 self.init_poller()
287 self.init_poller()
288 self.init_sockets()
288 self.init_sockets()
289 # writing connection file must be *after* init_sockets
289 # writing connection file must be *after* init_sockets
290 self.write_connection_file()
290 self.write_connection_file()
291 self.init_io()
291 self.init_io()
292 self.init_kernel()
292 self.init_kernel()
293 # flush stdout/stderr, so that anything written to these streams during
293 # flush stdout/stderr, so that anything written to these streams during
294 # initialization do not get associated with the first execution request
294 # initialization do not get associated with the first execution request
295 sys.stdout.flush()
295 sys.stdout.flush()
296 sys.stderr.flush()
296 sys.stderr.flush()
297
297
298 def start(self):
298 def start(self):
299 self.heartbeat.start()
299 self.heartbeat.start()
300 if self.poller is not None:
300 if self.poller is not None:
301 self.poller.start()
301 self.poller.start()
302 try:
302 try:
303 self.kernel.start()
303 self.kernel.start()
304 except KeyboardInterrupt:
304 except KeyboardInterrupt:
305 pass
305 pass
306
306
General Comments 0
You need to be logged in to leave comments. Login now