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