##// END OF EJS Templates
Merge
Fernando Perez -
r1205:bafa8473 merge
parent child Browse files
Show More

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

@@ -1,364 +1,386 b''
1 1
2 2 """ Implementations for various useful completers
3 3
4 4 See Extensions/ipy_stock_completers.py on examples of how to enable a completer,
5 5 but the basic idea is to do:
6 6
7 7 ip.set_hook('complete_command', svn_completer, str_key = 'svn')
8 8
9 9 """
10 10 import IPython.ipapi
11 11 import glob,os,shlex,sys
12 12 import inspect
13 13 from time import time
14 14 from zipimport import zipimporter
15 15 ip = IPython.ipapi.get()
16 16
17 17 try:
18 18 set
19 19 except:
20 20 from sets import Set as set
21 21
22 22 TIMEOUT_STORAGE = 3 #Time in seconds after which the rootmodules will be stored
23 23 TIMEOUT_GIVEUP = 20 #Time in seconds after which we give up
24 24
25 25 def quick_completer(cmd, completions):
26 26 """ Easily create a trivial completer for a command.
27 27
28 28 Takes either a list of completions, or all completions in string
29 29 (that will be split on whitespace)
30 30
31 31 Example::
32 32
33 33 [d:\ipython]|1> import ipy_completers
34 34 [d:\ipython]|2> ipy_completers.quick_completer('foo', ['bar','baz'])
35 35 [d:\ipython]|3> foo b<TAB>
36 36 bar baz
37 37 [d:\ipython]|3> foo ba
38 38 """
39 39 if isinstance(completions, basestring):
40 40
41 41 completions = completions.split()
42 42 def do_complete(self,event):
43 43 return completions
44 44
45 45 ip.set_hook('complete_command',do_complete, str_key = cmd)
46 46
47 47 def getRootModules():
48 48 """
49 49 Returns a list containing the names of all the modules available in the
50 50 folders of the pythonpath.
51 51 """
52 52 modules = []
53 53 if ip.db.has_key('rootmodules'):
54 54 return ip.db['rootmodules']
55 55 t = time()
56 56 store = False
57 57 for path in sys.path:
58 58 modules += moduleList(path)
59 59 if time() - t >= TIMEOUT_STORAGE and not store:
60 60 store = True
61 61 print "\nCaching the list of root modules, please wait!"
62 62 print "(This will only be done once - type '%rehashx' to " + \
63 63 "reset cache!)"
64 64 print
65 65 if time() - t > TIMEOUT_GIVEUP:
66 66 print "This is taking too long, we give up."
67 67 print
68 68 ip.db['rootmodules'] = []
69 69 return []
70 70
71 71 modules += sys.builtin_module_names
72 72
73 73 modules = list(set(modules))
74 74 if '__init__' in modules:
75 75 modules.remove('__init__')
76 76 modules = list(set(modules))
77 77 if store:
78 78 ip.db['rootmodules'] = modules
79 79 return modules
80 80
81 81 def moduleList(path):
82 82 """
83 83 Return the list containing the names of the modules available in the given
84 84 folder.
85 85 """
86 86
87 87 if os.path.isdir(path):
88 88 folder_list = os.listdir(path)
89 89 elif path.endswith('.egg'):
90 90 try:
91 91 folder_list = [f for f in zipimporter(path)._files]
92 92 except:
93 93 folder_list = []
94 94 else:
95 95 folder_list = []
96 96 #folder_list = glob.glob(os.path.join(path,'*'))
97 97 folder_list = [p for p in folder_list \
98 98 if os.path.exists(os.path.join(path, p,'__init__.py'))\
99 99 or p[-3:] in ('.py','.so')\
100 100 or p[-4:] in ('.pyc','.pyo','.pyd')]
101 101
102 102 folder_list = [os.path.basename(p).split('.')[0] for p in folder_list]
103 103 return folder_list
104 104
105 105 def moduleCompletion(line):
106 106 """
107 107 Returns a list containing the completion possibilities for an import line.
108 108 The line looks like this :
109 109 'import xml.d'
110 110 'from xml.dom import'
111 111 """
112 112 def tryImport(mod, only_modules=False):
113 113 def isImportable(module, attr):
114 114 if only_modules:
115 115 return inspect.ismodule(getattr(module, attr))
116 116 else:
117 117 return not(attr[:2] == '__' and attr[-2:] == '__')
118 118 try:
119 119 m = __import__(mod)
120 120 except:
121 121 return []
122 122 mods = mod.split('.')
123 123 for module in mods[1:]:
124 124 m = getattr(m,module)
125 125 if (not hasattr(m, '__file__')) or (not only_modules) or\
126 126 (hasattr(m, '__file__') and '__init__' in m.__file__):
127 127 completion_list = [attr for attr in dir(m) if isImportable(m, attr)]
128 128 completion_list.extend(getattr(m,'__all__',[]))
129 129 if hasattr(m, '__file__') and '__init__' in m.__file__:
130 130 completion_list.extend(moduleList(os.path.dirname(m.__file__)))
131 131 completion_list = list(set(completion_list))
132 132 if '__init__' in completion_list:
133 133 completion_list.remove('__init__')
134 134 return completion_list
135 135
136 136 words = line.split(' ')
137 137 if len(words) == 3 and words[0] == 'from':
138 138 return ['import ']
139 139 if len(words) < 3 and (words[0] in ['import','from']) :
140 140 if len(words) == 1:
141 141 return getRootModules()
142 142 mod = words[1].split('.')
143 143 if len(mod) < 2:
144 144 return getRootModules()
145 145 completion_list = tryImport('.'.join(mod[:-1]), True)
146 146 completion_list = ['.'.join(mod[:-1] + [el]) for el in completion_list]
147 147 return completion_list
148 148 if len(words) >= 3 and words[0] == 'from':
149 149 mod = words[1]
150 150 return tryImport(mod)
151 151
152 152 def vcs_completer(commands, event):
153 153 """ utility to make writing typical version control app completers easier
154 154
155 155 VCS command line apps typically have the format:
156 156
157 157 [sudo ]PROGNAME [help] [command] file file...
158 158
159 159 """
160 160
161 161
162 162 cmd_param = event.line.split()
163 163 if event.line.endswith(' '):
164 164 cmd_param.append('')
165 165
166 166 if cmd_param[0] == 'sudo':
167 167 cmd_param = cmd_param[1:]
168 168
169 169 if len(cmd_param) == 2 or 'help' in cmd_param:
170 170 return commands.split()
171 171
172 172 return ip.IP.Completer.file_matches(event.symbol)
173 173
174 174
175 175 pkg_cache = None
176 176
177 177 def module_completer(self,event):
178 178 """ Give completions after user has typed 'import ...' or 'from ...'"""
179 179
180 180 # This works in all versions of python. While 2.5 has
181 181 # pkgutil.walk_packages(), that particular routine is fairly dangerous,
182 182 # since it imports *EVERYTHING* on sys.path. That is: a) very slow b) full
183 183 # of possibly problematic side effects.
184 184 # This search the folders in the sys.path for available modules.
185 185
186 186 return moduleCompletion(event.line)
187 187
188 188
189 189 svn_commands = """\
190 190 add blame praise annotate ann cat checkout co cleanup commit ci copy
191 191 cp delete del remove rm diff di export help ? h import info list ls
192 192 lock log merge mkdir move mv rename ren propdel pdel pd propedit pedit
193 193 pe propget pget pg proplist plist pl propset pset ps resolved revert
194 194 status stat st switch sw unlock update
195 195 """
196 196
197 197 def svn_completer(self,event):
198 198 return vcs_completer(svn_commands, event)
199 199
200 200
201 201 hg_commands = """
202 202 add addremove annotate archive backout branch branches bundle cat
203 203 clone commit copy diff export grep heads help identify import incoming
204 204 init locate log manifest merge outgoing parents paths pull push
205 205 qapplied qclone qcommit qdelete qdiff qfold qguard qheader qimport
206 206 qinit qnew qnext qpop qprev qpush qrefresh qrename qrestore qsave
207 207 qselect qseries qtop qunapplied recover remove rename revert rollback
208 208 root serve showconfig status strip tag tags tip unbundle update verify
209 209 version
210 210 """
211 211
212 212 def hg_completer(self,event):
213 213 """ Completer for mercurial commands """
214 214
215 215 return vcs_completer(hg_commands, event)
216 216
217 217
218 218
219 219 __bzr_commands = None
220 220
221 221 def bzr_commands():
222 222 global __bzr_commands
223 223 if __bzr_commands is not None:
224 224 return __bzr_commands
225 225 out = os.popen('bzr help commands')
226 226 __bzr_commands = [l.split()[0] for l in out]
227 227 return __bzr_commands
228 228
229 229 def bzr_completer(self,event):
230 230 """ Completer for bazaar commands """
231 231 cmd_param = event.line.split()
232 232 if event.line.endswith(' '):
233 233 cmd_param.append('')
234 234
235 235 if len(cmd_param) > 2:
236 236 cmd = cmd_param[1]
237 237 param = cmd_param[-1]
238 238 output_file = (param == '--output=')
239 239 if cmd == 'help':
240 240 return bzr_commands()
241 241 elif cmd in ['bundle-revisions','conflicts',
242 242 'deleted','nick','register-branch',
243 243 'serve','unbind','upgrade','version',
244 244 'whoami'] and not output_file:
245 245 return []
246 246 else:
247 247 # the rest are probably file names
248 248 return ip.IP.Completer.file_matches(event.symbol)
249 249
250 250 return bzr_commands()
251 251
252 252
253 253 def shlex_split(x):
254 254 """Helper function to split lines into segments."""
255 255 #shlex.split raise exception if syntax error in sh syntax
256 256 #for example if no closing " is found. This function keeps dropping
257 257 #the last character of the line until shlex.split does not raise
258 258 #exception. Adds end of the line to the result of shlex.split
259 259 #example: %run "c:/python -> ['%run','"c:/python']
260 260 endofline=[]
261 261 while x!="":
262 262 try:
263 263 comps=shlex.split(x)
264 264 if len(endofline)>=1:
265 265 comps.append("".join(endofline))
266 266 return comps
267 267 except ValueError:
268 268 endofline=[x[-1:]]+endofline
269 269 x=x[:-1]
270 270 return ["".join(endofline)]
271 271
272 272 def runlistpy(self, event):
273 273 comps = shlex_split(event.line)
274 274 relpath = (len(comps) > 1 and comps[-1] or '').strip("'\"")
275 275
276 276 #print "\nev=",event # dbg
277 277 #print "rp=",relpath # dbg
278 278 #print 'comps=',comps # dbg
279 279
280 280 lglob = glob.glob
281 281 isdir = os.path.isdir
282 282 if relpath.startswith('~'):
283 283 relpath = os.path.expanduser(relpath)
284 284 dirs = [f.replace('\\','/') + "/" for f in lglob(relpath+'*')
285 285 if isdir(f)]
286 286
287 287 # Find if the user has already typed the first filename, after which we
288 288 # should complete on all files, since after the first one other files may
289 289 # be arguments to the input script.
290 290 #filter(
291 291 if filter(lambda f: f.endswith('.py') or f.endswith('.ipy') or
292 292 f.endswith('.pyw'),comps):
293 293 pys = [f.replace('\\','/') for f in lglob('*')]
294 294 else:
295 295 pys = [f.replace('\\','/')
296 296 for f in lglob(relpath+'*.py') + lglob(relpath+'*.ipy') +
297 297 lglob(relpath + '*.pyw')]
298 298 return dirs + pys
299 299
300 300
301 301 def cd_completer(self, event):
302 302 relpath = event.symbol
303 303 #print event # dbg
304 304 if '-b' in event.line:
305 305 # return only bookmark completions
306 306 bkms = self.db.get('bookmarks',{})
307 307 return bkms.keys()
308 308
309 309
310 310 if event.symbol == '-':
311 311 width_dh = str(len(str(len(ip.user_ns['_dh']) + 1)))
312 312 # jump in directory history by number
313 313 fmt = '-%0' + width_dh +'d [%s]'
314 314 ents = [ fmt % (i,s) for i,s in enumerate(ip.user_ns['_dh'])]
315 315 if len(ents) > 1:
316 316 return ents
317 317 return []
318 318
319 319 if relpath.startswith('~'):
320 320 relpath = os.path.expanduser(relpath).replace('\\','/')
321 321 found = []
322 322 for d in [f.replace('\\','/') + '/' for f in glob.glob(relpath+'*')
323 323 if os.path.isdir(f)]:
324 324 if ' ' in d:
325 325 # we don't want to deal with any of that, complex code
326 326 # for this is elsewhere
327 327 raise IPython.ipapi.TryNext
328 328 found.append( d )
329 329
330 330 if not found:
331 331 if os.path.isdir(relpath):
332 332 return [relpath]
333 333 raise IPython.ipapi.TryNext
334 return found
334
335
336 def single_dir_expand(matches):
337 "Recursively expand match lists containing a single dir."
338
339 if len(matches) == 1 and os.path.isdir(matches[0]):
340 # Takes care of links to directories also. Use '/'
341 # explicitly, even under Windows, so that name completions
342 # don't end up escaped.
343 d = matches[0]
344 if d[-1] in ['/','\\']:
345 d = d[:-1]
346
347 subdirs = [p for p in os.listdir(d) if os.path.isdir( d + '/' + p)]
348 if subdirs:
349 matches = [ (d + '/' + p) for p in subdirs ]
350 return single_dir_expand(matches)
351 else:
352 return matches
353 else:
354 return matches
355
356 return single_dir_expand(found)
335 357
336 358 def apt_get_packages(prefix):
337 359 out = os.popen('apt-cache pkgnames')
338 360 for p in out:
339 361 if p.startswith(prefix):
340 362 yield p.rstrip()
341 363
342 364
343 365 apt_commands = """\
344 366 update upgrade install remove purge source build-dep dist-upgrade
345 367 dselect-upgrade clean autoclean check"""
346 368
347 369 def apt_completer(self, event):
348 370 """ Completer for apt-get (uses apt-cache internally)
349 371
350 372 """
351 373
352 374
353 375 cmd_param = event.line.split()
354 376 if event.line.endswith(' '):
355 377 cmd_param.append('')
356 378
357 379 if cmd_param[0] == 'sudo':
358 380 cmd_param = cmd_param[1:]
359 381
360 382 if len(cmd_param) == 2 or 'help' in cmd_param:
361 383 return apt_commands.split()
362 384
363 385 return list(apt_get_packages(event.symbol))
364 386
@@ -1,3311 +1,3311 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Magic functions for InteractiveShell.
3 3
4 4 $Id: Magic.py 2996 2008-01-30 06:31:39Z fperez $"""
5 5
6 6 #*****************************************************************************
7 7 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
8 8 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
9 9 #
10 10 # Distributed under the terms of the BSD License. The full license is in
11 11 # the file COPYING, distributed as part of this software.
12 12 #*****************************************************************************
13 13
14 14 #****************************************************************************
15 15 # Modules and globals
16 16
17 17 from IPython import Release
18 18 __author__ = '%s <%s>\n%s <%s>' % \
19 19 ( Release.authors['Janko'] + Release.authors['Fernando'] )
20 20 __license__ = Release.license
21 21
22 22 # Python standard modules
23 23 import __builtin__
24 24 import bdb
25 25 import inspect
26 26 import os
27 27 import pdb
28 28 import pydoc
29 29 import sys
30 30 import re
31 31 import tempfile
32 32 import time
33 33 import cPickle as pickle
34 34 import textwrap
35 35 from cStringIO import StringIO
36 36 from getopt import getopt,GetoptError
37 37 from pprint import pprint, pformat
38 38 from sets import Set
39 39
40 40 # cProfile was added in Python2.5
41 41 try:
42 42 import cProfile as profile
43 43 import pstats
44 44 except ImportError:
45 45 # profile isn't bundled by default in Debian for license reasons
46 46 try:
47 47 import profile,pstats
48 48 except ImportError:
49 49 profile = pstats = None
50 50
51 51 # Homebrewed
52 52 import IPython
53 53 from IPython import Debugger, OInspect, wildcard
54 54 from IPython.FakeModule import FakeModule
55 55 from IPython.Itpl import Itpl, itpl, printpl,itplns
56 56 from IPython.PyColorize import Parser
57 57 from IPython.ipstruct import Struct
58 58 from IPython.macro import Macro
59 59 from IPython.genutils import *
60 60 from IPython import platutils
61 61 import IPython.generics
62 62 import IPython.ipapi
63 63 from IPython.ipapi import UsageError
64 64 #***************************************************************************
65 65 # Utility functions
66 66 def on_off(tag):
67 67 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
68 68 return ['OFF','ON'][tag]
69 69
70 70 class Bunch: pass
71 71
72 72 def compress_dhist(dh):
73 73 head, tail = dh[:-10], dh[-10:]
74 74
75 75 newhead = []
76 76 done = Set()
77 77 for h in head:
78 78 if h in done:
79 79 continue
80 80 newhead.append(h)
81 81 done.add(h)
82 82
83 83 return newhead + tail
84 84
85 85
86 86 #***************************************************************************
87 87 # Main class implementing Magic functionality
88 88 class Magic:
89 89 """Magic functions for InteractiveShell.
90 90
91 91 Shell functions which can be reached as %function_name. All magic
92 92 functions should accept a string, which they can parse for their own
93 93 needs. This can make some functions easier to type, eg `%cd ../`
94 94 vs. `%cd("../")`
95 95
96 96 ALL definitions MUST begin with the prefix magic_. The user won't need it
97 97 at the command line, but it is is needed in the definition. """
98 98
99 99 # class globals
100 100 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
101 101 'Automagic is ON, % prefix NOT needed for magic functions.']
102 102
103 103 #......................................................................
104 104 # some utility functions
105 105
106 106 def __init__(self,shell):
107 107
108 108 self.options_table = {}
109 109 if profile is None:
110 110 self.magic_prun = self.profile_missing_notice
111 111 self.shell = shell
112 112
113 113 # namespace for holding state we may need
114 114 self._magic_state = Bunch()
115 115
116 116 def profile_missing_notice(self, *args, **kwargs):
117 117 error("""\
118 118 The profile module could not be found. It has been removed from the standard
119 119 python packages because of its non-free license. To use profiling, install the
120 120 python-profiler package from non-free.""")
121 121
122 122 def default_option(self,fn,optstr):
123 123 """Make an entry in the options_table for fn, with value optstr"""
124 124
125 125 if fn not in self.lsmagic():
126 126 error("%s is not a magic function" % fn)
127 127 self.options_table[fn] = optstr
128 128
129 129 def lsmagic(self):
130 130 """Return a list of currently available magic functions.
131 131
132 132 Gives a list of the bare names after mangling (['ls','cd', ...], not
133 133 ['magic_ls','magic_cd',...]"""
134 134
135 135 # FIXME. This needs a cleanup, in the way the magics list is built.
136 136
137 137 # magics in class definition
138 138 class_magic = lambda fn: fn.startswith('magic_') and \
139 139 callable(Magic.__dict__[fn])
140 140 # in instance namespace (run-time user additions)
141 141 inst_magic = lambda fn: fn.startswith('magic_') and \
142 142 callable(self.__dict__[fn])
143 143 # and bound magics by user (so they can access self):
144 144 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
145 145 callable(self.__class__.__dict__[fn])
146 146 magics = filter(class_magic,Magic.__dict__.keys()) + \
147 147 filter(inst_magic,self.__dict__.keys()) + \
148 148 filter(inst_bound_magic,self.__class__.__dict__.keys())
149 149 out = []
150 150 for fn in Set(magics):
151 151 out.append(fn.replace('magic_','',1))
152 152 out.sort()
153 153 return out
154 154
155 155 def extract_input_slices(self,slices,raw=False):
156 156 """Return as a string a set of input history slices.
157 157
158 158 Inputs:
159 159
160 160 - slices: the set of slices is given as a list of strings (like
161 161 ['1','4:8','9'], since this function is for use by magic functions
162 162 which get their arguments as strings.
163 163
164 164 Optional inputs:
165 165
166 166 - raw(False): by default, the processed input is used. If this is
167 167 true, the raw input history is used instead.
168 168
169 169 Note that slices can be called with two notations:
170 170
171 171 N:M -> standard python form, means including items N...(M-1).
172 172
173 173 N-M -> include items N..M (closed endpoint)."""
174 174
175 175 if raw:
176 176 hist = self.shell.input_hist_raw
177 177 else:
178 178 hist = self.shell.input_hist
179 179
180 180 cmds = []
181 181 for chunk in slices:
182 182 if ':' in chunk:
183 183 ini,fin = map(int,chunk.split(':'))
184 184 elif '-' in chunk:
185 185 ini,fin = map(int,chunk.split('-'))
186 186 fin += 1
187 187 else:
188 188 ini = int(chunk)
189 189 fin = ini+1
190 190 cmds.append(hist[ini:fin])
191 191 return cmds
192 192
193 193 def _ofind(self, oname, namespaces=None):
194 194 """Find an object in the available namespaces.
195 195
196 196 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
197 197
198 198 Has special code to detect magic functions.
199 199 """
200 200
201 201 oname = oname.strip()
202 202
203 203 alias_ns = None
204 204 if namespaces is None:
205 205 # Namespaces to search in:
206 206 # Put them in a list. The order is important so that we
207 207 # find things in the same order that Python finds them.
208 208 namespaces = [ ('Interactive', self.shell.user_ns),
209 209 ('IPython internal', self.shell.internal_ns),
210 210 ('Python builtin', __builtin__.__dict__),
211 211 ('Alias', self.shell.alias_table),
212 212 ]
213 213 alias_ns = self.shell.alias_table
214 214
215 215 # initialize results to 'null'
216 216 found = 0; obj = None; ospace = None; ds = None;
217 217 ismagic = 0; isalias = 0; parent = None
218 218
219 219 # Look for the given name by splitting it in parts. If the head is
220 220 # found, then we look for all the remaining parts as members, and only
221 221 # declare success if we can find them all.
222 222 oname_parts = oname.split('.')
223 223 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
224 224 for nsname,ns in namespaces:
225 225 try:
226 226 obj = ns[oname_head]
227 227 except KeyError:
228 228 continue
229 229 else:
230 230 #print 'oname_rest:', oname_rest # dbg
231 231 for part in oname_rest:
232 232 try:
233 233 parent = obj
234 234 obj = getattr(obj,part)
235 235 except:
236 236 # Blanket except b/c some badly implemented objects
237 237 # allow __getattr__ to raise exceptions other than
238 238 # AttributeError, which then crashes IPython.
239 239 break
240 240 else:
241 241 # If we finish the for loop (no break), we got all members
242 242 found = 1
243 243 ospace = nsname
244 244 if ns == alias_ns:
245 245 isalias = 1
246 246 break # namespace loop
247 247
248 248 # Try to see if it's magic
249 249 if not found:
250 250 if oname.startswith(self.shell.ESC_MAGIC):
251 251 oname = oname[1:]
252 252 obj = getattr(self,'magic_'+oname,None)
253 253 if obj is not None:
254 254 found = 1
255 255 ospace = 'IPython internal'
256 256 ismagic = 1
257 257
258 258 # Last try: special-case some literals like '', [], {}, etc:
259 259 if not found and oname_head in ["''",'""','[]','{}','()']:
260 260 obj = eval(oname_head)
261 261 found = 1
262 262 ospace = 'Interactive'
263 263
264 264 return {'found':found, 'obj':obj, 'namespace':ospace,
265 265 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
266 266
267 267 def arg_err(self,func):
268 268 """Print docstring if incorrect arguments were passed"""
269 269 print 'Error in arguments:'
270 270 print OInspect.getdoc(func)
271 271
272 272 def format_latex(self,strng):
273 273 """Format a string for latex inclusion."""
274 274
275 275 # Characters that need to be escaped for latex:
276 276 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
277 277 # Magic command names as headers:
278 278 cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
279 279 re.MULTILINE)
280 280 # Magic commands
281 281 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
282 282 re.MULTILINE)
283 283 # Paragraph continue
284 284 par_re = re.compile(r'\\$',re.MULTILINE)
285 285
286 286 # The "\n" symbol
287 287 newline_re = re.compile(r'\\n')
288 288
289 289 # Now build the string for output:
290 290 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
291 291 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
292 292 strng)
293 293 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
294 294 strng = par_re.sub(r'\\\\',strng)
295 295 strng = escape_re.sub(r'\\\1',strng)
296 296 strng = newline_re.sub(r'\\textbackslash{}n',strng)
297 297 return strng
298 298
299 299 def format_screen(self,strng):
300 300 """Format a string for screen printing.
301 301
302 302 This removes some latex-type format codes."""
303 303 # Paragraph continue
304 304 par_re = re.compile(r'\\$',re.MULTILINE)
305 305 strng = par_re.sub('',strng)
306 306 return strng
307 307
308 308 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
309 309 """Parse options passed to an argument string.
310 310
311 311 The interface is similar to that of getopt(), but it returns back a
312 312 Struct with the options as keys and the stripped argument string still
313 313 as a string.
314 314
315 315 arg_str is quoted as a true sys.argv vector by using shlex.split.
316 316 This allows us to easily expand variables, glob files, quote
317 317 arguments, etc.
318 318
319 319 Options:
320 320 -mode: default 'string'. If given as 'list', the argument string is
321 321 returned as a list (split on whitespace) instead of a string.
322 322
323 323 -list_all: put all option values in lists. Normally only options
324 324 appearing more than once are put in a list.
325 325
326 326 -posix (True): whether to split the input line in POSIX mode or not,
327 327 as per the conventions outlined in the shlex module from the
328 328 standard library."""
329 329
330 330 # inject default options at the beginning of the input line
331 331 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
332 332 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
333 333
334 334 mode = kw.get('mode','string')
335 335 if mode not in ['string','list']:
336 336 raise ValueError,'incorrect mode given: %s' % mode
337 337 # Get options
338 338 list_all = kw.get('list_all',0)
339 339 posix = kw.get('posix',True)
340 340
341 341 # Check if we have more than one argument to warrant extra processing:
342 342 odict = {} # Dictionary with options
343 343 args = arg_str.split()
344 344 if len(args) >= 1:
345 345 # If the list of inputs only has 0 or 1 thing in it, there's no
346 346 # need to look for options
347 347 argv = arg_split(arg_str,posix)
348 348 # Do regular option processing
349 349 try:
350 350 opts,args = getopt(argv,opt_str,*long_opts)
351 351 except GetoptError,e:
352 352 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
353 353 " ".join(long_opts)))
354 354 for o,a in opts:
355 355 if o.startswith('--'):
356 356 o = o[2:]
357 357 else:
358 358 o = o[1:]
359 359 try:
360 360 odict[o].append(a)
361 361 except AttributeError:
362 362 odict[o] = [odict[o],a]
363 363 except KeyError:
364 364 if list_all:
365 365 odict[o] = [a]
366 366 else:
367 367 odict[o] = a
368 368
369 369 # Prepare opts,args for return
370 370 opts = Struct(odict)
371 371 if mode == 'string':
372 372 args = ' '.join(args)
373 373
374 374 return opts,args
375 375
376 376 #......................................................................
377 377 # And now the actual magic functions
378 378
379 379 # Functions for IPython shell work (vars,funcs, config, etc)
380 380 def magic_lsmagic(self, parameter_s = ''):
381 381 """List currently available magic functions."""
382 382 mesc = self.shell.ESC_MAGIC
383 383 print 'Available magic functions:\n'+mesc+\
384 384 (' '+mesc).join(self.lsmagic())
385 385 print '\n' + Magic.auto_status[self.shell.rc.automagic]
386 386 return None
387 387
388 388 def magic_magic(self, parameter_s = ''):
389 389 """Print information about the magic function system.
390 390
391 391 Supported formats: -latex, -brief, -rest
392 392 """
393 393
394 394 mode = ''
395 395 try:
396 396 if parameter_s.split()[0] == '-latex':
397 397 mode = 'latex'
398 398 if parameter_s.split()[0] == '-brief':
399 399 mode = 'brief'
400 400 if parameter_s.split()[0] == '-rest':
401 401 mode = 'rest'
402 402 rest_docs = []
403 403 except:
404 404 pass
405 405
406 406 magic_docs = []
407 407 for fname in self.lsmagic():
408 408 mname = 'magic_' + fname
409 409 for space in (Magic,self,self.__class__):
410 410 try:
411 411 fn = space.__dict__[mname]
412 412 except KeyError:
413 413 pass
414 414 else:
415 415 break
416 416 if mode == 'brief':
417 417 # only first line
418 418 if fn.__doc__:
419 419 fndoc = fn.__doc__.split('\n',1)[0]
420 420 else:
421 421 fndoc = 'No documentation'
422 422 else:
423 423 fndoc = fn.__doc__.rstrip()
424 424
425 425 if mode == 'rest':
426 426 rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(self.shell.ESC_MAGIC,
427 427 fname,fndoc))
428 428
429 429 else:
430 430 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
431 431 fname,fndoc))
432 432
433 433 magic_docs = ''.join(magic_docs)
434 434
435 435 if mode == 'rest':
436 436 return "".join(rest_docs)
437 437
438 438 if mode == 'latex':
439 439 print self.format_latex(magic_docs)
440 440 return
441 441 else:
442 442 magic_docs = self.format_screen(magic_docs)
443 443 if mode == 'brief':
444 444 return magic_docs
445 445
446 446 outmsg = """
447 447 IPython's 'magic' functions
448 448 ===========================
449 449
450 450 The magic function system provides a series of functions which allow you to
451 451 control the behavior of IPython itself, plus a lot of system-type
452 452 features. All these functions are prefixed with a % character, but parameters
453 453 are given without parentheses or quotes.
454 454
455 455 NOTE: If you have 'automagic' enabled (via the command line option or with the
456 456 %automagic function), you don't need to type in the % explicitly. By default,
457 457 IPython ships with automagic on, so you should only rarely need the % escape.
458 458
459 459 Example: typing '%cd mydir' (without the quotes) changes you working directory
460 460 to 'mydir', if it exists.
461 461
462 462 You can define your own magic functions to extend the system. See the supplied
463 463 ipythonrc and example-magic.py files for details (in your ipython
464 464 configuration directory, typically $HOME/.ipython/).
465 465
466 466 You can also define your own aliased names for magic functions. In your
467 467 ipythonrc file, placing a line like:
468 468
469 469 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
470 470
471 471 will define %pf as a new name for %profile.
472 472
473 473 You can also call magics in code using the ipmagic() function, which IPython
474 474 automatically adds to the builtin namespace. Type 'ipmagic?' for details.
475 475
476 476 For a list of the available magic functions, use %lsmagic. For a description
477 477 of any of them, type %magic_name?, e.g. '%cd?'.
478 478
479 479 Currently the magic system has the following functions:\n"""
480 480
481 481 mesc = self.shell.ESC_MAGIC
482 482 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
483 483 "\n\n%s%s\n\n%s" % (outmsg,
484 484 magic_docs,mesc,mesc,
485 485 (' '+mesc).join(self.lsmagic()),
486 486 Magic.auto_status[self.shell.rc.automagic] ) )
487 487
488 488 page(outmsg,screen_lines=self.shell.rc.screen_length)
489 489
490 490
491 491 def magic_autoindent(self, parameter_s = ''):
492 492 """Toggle autoindent on/off (if available)."""
493 493
494 494 self.shell.set_autoindent()
495 495 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
496 496
497 497
498 498 def magic_automagic(self, parameter_s = ''):
499 499 """Make magic functions callable without having to type the initial %.
500 500
501 501 Without argumentsl toggles on/off (when off, you must call it as
502 502 %automagic, of course). With arguments it sets the value, and you can
503 503 use any of (case insensitive):
504 504
505 505 - on,1,True: to activate
506 506
507 507 - off,0,False: to deactivate.
508 508
509 509 Note that magic functions have lowest priority, so if there's a
510 510 variable whose name collides with that of a magic fn, automagic won't
511 511 work for that function (you get the variable instead). However, if you
512 512 delete the variable (del var), the previously shadowed magic function
513 513 becomes visible to automagic again."""
514 514
515 515 rc = self.shell.rc
516 516 arg = parameter_s.lower()
517 517 if parameter_s in ('on','1','true'):
518 518 rc.automagic = True
519 519 elif parameter_s in ('off','0','false'):
520 520 rc.automagic = False
521 521 else:
522 522 rc.automagic = not rc.automagic
523 523 print '\n' + Magic.auto_status[rc.automagic]
524 524
525 525
526 526 def magic_autocall(self, parameter_s = ''):
527 527 """Make functions callable without having to type parentheses.
528 528
529 529 Usage:
530 530
531 531 %autocall [mode]
532 532
533 533 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
534 534 value is toggled on and off (remembering the previous state).
535 535
536 536 In more detail, these values mean:
537 537
538 538 0 -> fully disabled
539 539
540 540 1 -> active, but do not apply if there are no arguments on the line.
541 541
542 542 In this mode, you get:
543 543
544 544 In [1]: callable
545 545 Out[1]: <built-in function callable>
546 546
547 547 In [2]: callable 'hello'
548 548 ------> callable('hello')
549 549 Out[2]: False
550 550
551 551 2 -> Active always. Even if no arguments are present, the callable
552 552 object is called:
553 553
554 554 In [4]: callable
555 555 ------> callable()
556 556
557 557 Note that even with autocall off, you can still use '/' at the start of
558 558 a line to treat the first argument on the command line as a function
559 559 and add parentheses to it:
560 560
561 561 In [8]: /str 43
562 562 ------> str(43)
563 563 Out[8]: '43'
564 564 """
565 565
566 566 rc = self.shell.rc
567 567
568 568 if parameter_s:
569 569 arg = int(parameter_s)
570 570 else:
571 571 arg = 'toggle'
572 572
573 573 if not arg in (0,1,2,'toggle'):
574 574 error('Valid modes: (0->Off, 1->Smart, 2->Full')
575 575 return
576 576
577 577 if arg in (0,1,2):
578 578 rc.autocall = arg
579 579 else: # toggle
580 580 if rc.autocall:
581 581 self._magic_state.autocall_save = rc.autocall
582 582 rc.autocall = 0
583 583 else:
584 584 try:
585 585 rc.autocall = self._magic_state.autocall_save
586 586 except AttributeError:
587 587 rc.autocall = self._magic_state.autocall_save = 1
588 588
589 589 print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
590 590
591 591 def magic_system_verbose(self, parameter_s = ''):
592 592 """Set verbose printing of system calls.
593 593
594 594 If called without an argument, act as a toggle"""
595 595
596 596 if parameter_s:
597 597 val = bool(eval(parameter_s))
598 598 else:
599 599 val = None
600 600
601 601 self.shell.rc_set_toggle('system_verbose',val)
602 602 print "System verbose printing is:",\
603 603 ['OFF','ON'][self.shell.rc.system_verbose]
604 604
605 605
606 606 def magic_page(self, parameter_s=''):
607 607 """Pretty print the object and display it through a pager.
608 608
609 609 %page [options] OBJECT
610 610
611 611 If no object is given, use _ (last output).
612 612
613 613 Options:
614 614
615 615 -r: page str(object), don't pretty-print it."""
616 616
617 617 # After a function contributed by Olivier Aubert, slightly modified.
618 618
619 619 # Process options/args
620 620 opts,args = self.parse_options(parameter_s,'r')
621 621 raw = 'r' in opts
622 622
623 623 oname = args and args or '_'
624 624 info = self._ofind(oname)
625 625 if info['found']:
626 626 txt = (raw and str or pformat)( info['obj'] )
627 627 page(txt)
628 628 else:
629 629 print 'Object `%s` not found' % oname
630 630
631 631 def magic_profile(self, parameter_s=''):
632 632 """Print your currently active IPyhton profile."""
633 633 if self.shell.rc.profile:
634 634 printpl('Current IPython profile: $self.shell.rc.profile.')
635 635 else:
636 636 print 'No profile active.'
637 637
638 638 def magic_pinfo(self, parameter_s='', namespaces=None):
639 639 """Provide detailed information about an object.
640 640
641 641 '%pinfo object' is just a synonym for object? or ?object."""
642 642
643 643 #print 'pinfo par: <%s>' % parameter_s # dbg
644 644
645 645
646 646 # detail_level: 0 -> obj? , 1 -> obj??
647 647 detail_level = 0
648 648 # We need to detect if we got called as 'pinfo pinfo foo', which can
649 649 # happen if the user types 'pinfo foo?' at the cmd line.
650 650 pinfo,qmark1,oname,qmark2 = \
651 651 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
652 652 if pinfo or qmark1 or qmark2:
653 653 detail_level = 1
654 654 if "*" in oname:
655 655 self.magic_psearch(oname)
656 656 else:
657 657 self._inspect('pinfo', oname, detail_level=detail_level,
658 658 namespaces=namespaces)
659 659
660 660 def magic_pdef(self, parameter_s='', namespaces=None):
661 661 """Print the definition header for any callable object.
662 662
663 663 If the object is a class, print the constructor information."""
664 664 self._inspect('pdef',parameter_s, namespaces)
665 665
666 666 def magic_pdoc(self, parameter_s='', namespaces=None):
667 667 """Print the docstring for an object.
668 668
669 669 If the given object is a class, it will print both the class and the
670 670 constructor docstrings."""
671 671 self._inspect('pdoc',parameter_s, namespaces)
672 672
673 673 def magic_psource(self, parameter_s='', namespaces=None):
674 674 """Print (or run through pager) the source code for an object."""
675 675 self._inspect('psource',parameter_s, namespaces)
676 676
677 677 def magic_pfile(self, parameter_s=''):
678 678 """Print (or run through pager) the file where an object is defined.
679 679
680 680 The file opens at the line where the object definition begins. IPython
681 681 will honor the environment variable PAGER if set, and otherwise will
682 682 do its best to print the file in a convenient form.
683 683
684 684 If the given argument is not an object currently defined, IPython will
685 685 try to interpret it as a filename (automatically adding a .py extension
686 686 if needed). You can thus use %pfile as a syntax highlighting code
687 687 viewer."""
688 688
689 689 # first interpret argument as an object name
690 690 out = self._inspect('pfile',parameter_s)
691 691 # if not, try the input as a filename
692 692 if out == 'not found':
693 693 try:
694 694 filename = get_py_filename(parameter_s)
695 695 except IOError,msg:
696 696 print msg
697 697 return
698 698 page(self.shell.inspector.format(file(filename).read()))
699 699
700 700 def _inspect(self,meth,oname,namespaces=None,**kw):
701 701 """Generic interface to the inspector system.
702 702
703 703 This function is meant to be called by pdef, pdoc & friends."""
704 704
705 705 #oname = oname.strip()
706 706 #print '1- oname: <%r>' % oname # dbg
707 707 try:
708 708 oname = oname.strip().encode('ascii')
709 709 #print '2- oname: <%r>' % oname # dbg
710 710 except UnicodeEncodeError:
711 711 print 'Python identifiers can only contain ascii characters.'
712 712 return 'not found'
713 713
714 714 info = Struct(self._ofind(oname, namespaces))
715 715
716 716 if info.found:
717 717 try:
718 718 IPython.generics.inspect_object(info.obj)
719 719 return
720 720 except IPython.ipapi.TryNext:
721 721 pass
722 722 # Get the docstring of the class property if it exists.
723 723 path = oname.split('.')
724 724 root = '.'.join(path[:-1])
725 725 if info.parent is not None:
726 726 try:
727 727 target = getattr(info.parent, '__class__')
728 728 # The object belongs to a class instance.
729 729 try:
730 730 target = getattr(target, path[-1])
731 731 # The class defines the object.
732 732 if isinstance(target, property):
733 733 oname = root + '.__class__.' + path[-1]
734 734 info = Struct(self._ofind(oname))
735 735 except AttributeError: pass
736 736 except AttributeError: pass
737 737
738 738 pmethod = getattr(self.shell.inspector,meth)
739 739 formatter = info.ismagic and self.format_screen or None
740 740 if meth == 'pdoc':
741 741 pmethod(info.obj,oname,formatter)
742 742 elif meth == 'pinfo':
743 743 pmethod(info.obj,oname,formatter,info,**kw)
744 744 else:
745 745 pmethod(info.obj,oname)
746 746 else:
747 747 print 'Object `%s` not found.' % oname
748 748 return 'not found' # so callers can take other action
749 749
750 750 def magic_psearch(self, parameter_s=''):
751 751 """Search for object in namespaces by wildcard.
752 752
753 753 %psearch [options] PATTERN [OBJECT TYPE]
754 754
755 755 Note: ? can be used as a synonym for %psearch, at the beginning or at
756 756 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
757 757 rest of the command line must be unchanged (options come first), so
758 758 for example the following forms are equivalent
759 759
760 760 %psearch -i a* function
761 761 -i a* function?
762 762 ?-i a* function
763 763
764 764 Arguments:
765 765
766 766 PATTERN
767 767
768 768 where PATTERN is a string containing * as a wildcard similar to its
769 769 use in a shell. The pattern is matched in all namespaces on the
770 770 search path. By default objects starting with a single _ are not
771 771 matched, many IPython generated objects have a single
772 772 underscore. The default is case insensitive matching. Matching is
773 773 also done on the attributes of objects and not only on the objects
774 774 in a module.
775 775
776 776 [OBJECT TYPE]
777 777
778 778 Is the name of a python type from the types module. The name is
779 779 given in lowercase without the ending type, ex. StringType is
780 780 written string. By adding a type here only objects matching the
781 781 given type are matched. Using all here makes the pattern match all
782 782 types (this is the default).
783 783
784 784 Options:
785 785
786 786 -a: makes the pattern match even objects whose names start with a
787 787 single underscore. These names are normally ommitted from the
788 788 search.
789 789
790 790 -i/-c: make the pattern case insensitive/sensitive. If neither of
791 791 these options is given, the default is read from your ipythonrc
792 792 file. The option name which sets this value is
793 793 'wildcards_case_sensitive'. If this option is not specified in your
794 794 ipythonrc file, IPython's internal default is to do a case sensitive
795 795 search.
796 796
797 797 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
798 798 specifiy can be searched in any of the following namespaces:
799 799 'builtin', 'user', 'user_global','internal', 'alias', where
800 800 'builtin' and 'user' are the search defaults. Note that you should
801 801 not use quotes when specifying namespaces.
802 802
803 803 'Builtin' contains the python module builtin, 'user' contains all
804 804 user data, 'alias' only contain the shell aliases and no python
805 805 objects, 'internal' contains objects used by IPython. The
806 806 'user_global' namespace is only used by embedded IPython instances,
807 807 and it contains module-level globals. You can add namespaces to the
808 808 search with -s or exclude them with -e (these options can be given
809 809 more than once).
810 810
811 811 Examples:
812 812
813 813 %psearch a* -> objects beginning with an a
814 814 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
815 815 %psearch a* function -> all functions beginning with an a
816 816 %psearch re.e* -> objects beginning with an e in module re
817 817 %psearch r*.e* -> objects that start with e in modules starting in r
818 818 %psearch r*.* string -> all strings in modules beginning with r
819 819
820 820 Case sensitve search:
821 821
822 822 %psearch -c a* list all object beginning with lower case a
823 823
824 824 Show objects beginning with a single _:
825 825
826 826 %psearch -a _* list objects beginning with a single underscore"""
827 827 try:
828 828 parameter_s = parameter_s.encode('ascii')
829 829 except UnicodeEncodeError:
830 830 print 'Python identifiers can only contain ascii characters.'
831 831 return
832 832
833 833 # default namespaces to be searched
834 834 def_search = ['user','builtin']
835 835
836 836 # Process options/args
837 837 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
838 838 opt = opts.get
839 839 shell = self.shell
840 840 psearch = shell.inspector.psearch
841 841
842 842 # select case options
843 843 if opts.has_key('i'):
844 844 ignore_case = True
845 845 elif opts.has_key('c'):
846 846 ignore_case = False
847 847 else:
848 848 ignore_case = not shell.rc.wildcards_case_sensitive
849 849
850 850 # Build list of namespaces to search from user options
851 851 def_search.extend(opt('s',[]))
852 852 ns_exclude = ns_exclude=opt('e',[])
853 853 ns_search = [nm for nm in def_search if nm not in ns_exclude]
854 854
855 855 # Call the actual search
856 856 try:
857 857 psearch(args,shell.ns_table,ns_search,
858 858 show_all=opt('a'),ignore_case=ignore_case)
859 859 except:
860 860 shell.showtraceback()
861 861
862 862 def magic_who_ls(self, parameter_s=''):
863 863 """Return a sorted list of all interactive variables.
864 864
865 865 If arguments are given, only variables of types matching these
866 866 arguments are returned."""
867 867
868 868 user_ns = self.shell.user_ns
869 869 internal_ns = self.shell.internal_ns
870 870 user_config_ns = self.shell.user_config_ns
871 871 out = []
872 872 typelist = parameter_s.split()
873 873
874 874 for i in user_ns:
875 875 if not (i.startswith('_') or i.startswith('_i')) \
876 876 and not (i in internal_ns or i in user_config_ns):
877 877 if typelist:
878 878 if type(user_ns[i]).__name__ in typelist:
879 879 out.append(i)
880 880 else:
881 881 out.append(i)
882 882 out.sort()
883 883 return out
884 884
885 885 def magic_who(self, parameter_s=''):
886 886 """Print all interactive variables, with some minimal formatting.
887 887
888 888 If any arguments are given, only variables whose type matches one of
889 889 these are printed. For example:
890 890
891 891 %who function str
892 892
893 893 will only list functions and strings, excluding all other types of
894 894 variables. To find the proper type names, simply use type(var) at a
895 895 command line to see how python prints type names. For example:
896 896
897 897 In [1]: type('hello')\\
898 898 Out[1]: <type 'str'>
899 899
900 900 indicates that the type name for strings is 'str'.
901 901
902 902 %who always excludes executed names loaded through your configuration
903 903 file and things which are internal to IPython.
904 904
905 905 This is deliberate, as typically you may load many modules and the
906 906 purpose of %who is to show you only what you've manually defined."""
907 907
908 908 varlist = self.magic_who_ls(parameter_s)
909 909 if not varlist:
910 910 if parameter_s:
911 911 print 'No variables match your requested type.'
912 912 else:
913 913 print 'Interactive namespace is empty.'
914 914 return
915 915
916 916 # if we have variables, move on...
917 917 count = 0
918 918 for i in varlist:
919 919 print i+'\t',
920 920 count += 1
921 921 if count > 8:
922 922 count = 0
923 923 print
924 924 print
925 925
926 926 def magic_whos(self, parameter_s=''):
927 927 """Like %who, but gives some extra information about each variable.
928 928
929 929 The same type filtering of %who can be applied here.
930 930
931 931 For all variables, the type is printed. Additionally it prints:
932 932
933 933 - For {},[],(): their length.
934 934
935 935 - For numpy and Numeric arrays, a summary with shape, number of
936 936 elements, typecode and size in memory.
937 937
938 938 - Everything else: a string representation, snipping their middle if
939 939 too long."""
940 940
941 941 varnames = self.magic_who_ls(parameter_s)
942 942 if not varnames:
943 943 if parameter_s:
944 944 print 'No variables match your requested type.'
945 945 else:
946 946 print 'Interactive namespace is empty.'
947 947 return
948 948
949 949 # if we have variables, move on...
950 950
951 951 # for these types, show len() instead of data:
952 952 seq_types = [types.DictType,types.ListType,types.TupleType]
953 953
954 954 # for numpy/Numeric arrays, display summary info
955 955 try:
956 956 import numpy
957 957 except ImportError:
958 958 ndarray_type = None
959 959 else:
960 960 ndarray_type = numpy.ndarray.__name__
961 961 try:
962 962 import Numeric
963 963 except ImportError:
964 964 array_type = None
965 965 else:
966 966 array_type = Numeric.ArrayType.__name__
967 967
968 968 # Find all variable names and types so we can figure out column sizes
969 969 def get_vars(i):
970 970 return self.shell.user_ns[i]
971 971
972 972 # some types are well known and can be shorter
973 973 abbrevs = {'IPython.macro.Macro' : 'Macro'}
974 974 def type_name(v):
975 975 tn = type(v).__name__
976 976 return abbrevs.get(tn,tn)
977 977
978 978 varlist = map(get_vars,varnames)
979 979
980 980 typelist = []
981 981 for vv in varlist:
982 982 tt = type_name(vv)
983 983
984 984 if tt=='instance':
985 985 typelist.append( abbrevs.get(str(vv.__class__),
986 986 str(vv.__class__)))
987 987 else:
988 988 typelist.append(tt)
989 989
990 990 # column labels and # of spaces as separator
991 991 varlabel = 'Variable'
992 992 typelabel = 'Type'
993 993 datalabel = 'Data/Info'
994 994 colsep = 3
995 995 # variable format strings
996 996 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
997 997 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
998 998 aformat = "%s: %s elems, type `%s`, %s bytes"
999 999 # find the size of the columns to format the output nicely
1000 1000 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
1001 1001 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
1002 1002 # table header
1003 1003 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
1004 1004 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
1005 1005 # and the table itself
1006 1006 kb = 1024
1007 1007 Mb = 1048576 # kb**2
1008 1008 for vname,var,vtype in zip(varnames,varlist,typelist):
1009 1009 print itpl(vformat),
1010 1010 if vtype in seq_types:
1011 1011 print len(var)
1012 1012 elif vtype in [array_type,ndarray_type]:
1013 1013 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
1014 1014 if vtype==ndarray_type:
1015 1015 # numpy
1016 1016 vsize = var.size
1017 1017 vbytes = vsize*var.itemsize
1018 1018 vdtype = var.dtype
1019 1019 else:
1020 1020 # Numeric
1021 1021 vsize = Numeric.size(var)
1022 1022 vbytes = vsize*var.itemsize()
1023 1023 vdtype = var.typecode()
1024 1024
1025 1025 if vbytes < 100000:
1026 1026 print aformat % (vshape,vsize,vdtype,vbytes)
1027 1027 else:
1028 1028 print aformat % (vshape,vsize,vdtype,vbytes),
1029 1029 if vbytes < Mb:
1030 1030 print '(%s kb)' % (vbytes/kb,)
1031 1031 else:
1032 1032 print '(%s Mb)' % (vbytes/Mb,)
1033 1033 else:
1034 1034 try:
1035 1035 vstr = str(var)
1036 1036 except UnicodeEncodeError:
1037 1037 vstr = unicode(var).encode(sys.getdefaultencoding(),
1038 1038 'backslashreplace')
1039 1039 vstr = vstr.replace('\n','\\n')
1040 1040 if len(vstr) < 50:
1041 1041 print vstr
1042 1042 else:
1043 1043 printpl(vfmt_short)
1044 1044
1045 1045 def magic_reset(self, parameter_s=''):
1046 1046 """Resets the namespace by removing all names defined by the user.
1047 1047
1048 1048 Input/Output history are left around in case you need them."""
1049 1049
1050 1050 ans = self.shell.ask_yes_no(
1051 1051 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
1052 1052 if not ans:
1053 1053 print 'Nothing done.'
1054 1054 return
1055 1055 user_ns = self.shell.user_ns
1056 1056 for i in self.magic_who_ls():
1057 1057 del(user_ns[i])
1058 1058
1059 1059 # Also flush the private list of module references kept for script
1060 1060 # execution protection
1061 1061 self.shell._user_main_modules[:] = []
1062 1062
1063 1063 def magic_logstart(self,parameter_s=''):
1064 1064 """Start logging anywhere in a session.
1065 1065
1066 1066 %logstart [-o|-r|-t] [log_name [log_mode]]
1067 1067
1068 1068 If no name is given, it defaults to a file named 'ipython_log.py' in your
1069 1069 current directory, in 'rotate' mode (see below).
1070 1070
1071 1071 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1072 1072 history up to that point and then continues logging.
1073 1073
1074 1074 %logstart takes a second optional parameter: logging mode. This can be one
1075 1075 of (note that the modes are given unquoted):\\
1076 1076 append: well, that says it.\\
1077 1077 backup: rename (if exists) to name~ and start name.\\
1078 1078 global: single logfile in your home dir, appended to.\\
1079 1079 over : overwrite existing log.\\
1080 1080 rotate: create rotating logs name.1~, name.2~, etc.
1081 1081
1082 1082 Options:
1083 1083
1084 1084 -o: log also IPython's output. In this mode, all commands which
1085 1085 generate an Out[NN] prompt are recorded to the logfile, right after
1086 1086 their corresponding input line. The output lines are always
1087 1087 prepended with a '#[Out]# ' marker, so that the log remains valid
1088 1088 Python code.
1089 1089
1090 1090 Since this marker is always the same, filtering only the output from
1091 1091 a log is very easy, using for example a simple awk call:
1092 1092
1093 1093 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1094 1094
1095 1095 -r: log 'raw' input. Normally, IPython's logs contain the processed
1096 1096 input, so that user lines are logged in their final form, converted
1097 1097 into valid Python. For example, %Exit is logged as
1098 1098 '_ip.magic("Exit"). If the -r flag is given, all input is logged
1099 1099 exactly as typed, with no transformations applied.
1100 1100
1101 1101 -t: put timestamps before each input line logged (these are put in
1102 1102 comments)."""
1103 1103
1104 1104 opts,par = self.parse_options(parameter_s,'ort')
1105 1105 log_output = 'o' in opts
1106 1106 log_raw_input = 'r' in opts
1107 1107 timestamp = 't' in opts
1108 1108
1109 1109 rc = self.shell.rc
1110 1110 logger = self.shell.logger
1111 1111
1112 1112 # if no args are given, the defaults set in the logger constructor by
1113 1113 # ipytohn remain valid
1114 1114 if par:
1115 1115 try:
1116 1116 logfname,logmode = par.split()
1117 1117 except:
1118 1118 logfname = par
1119 1119 logmode = 'backup'
1120 1120 else:
1121 1121 logfname = logger.logfname
1122 1122 logmode = logger.logmode
1123 1123 # put logfname into rc struct as if it had been called on the command
1124 1124 # line, so it ends up saved in the log header Save it in case we need
1125 1125 # to restore it...
1126 1126 old_logfile = rc.opts.get('logfile','')
1127 1127 if logfname:
1128 1128 logfname = os.path.expanduser(logfname)
1129 1129 rc.opts.logfile = logfname
1130 1130 loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
1131 1131 try:
1132 1132 started = logger.logstart(logfname,loghead,logmode,
1133 1133 log_output,timestamp,log_raw_input)
1134 1134 except:
1135 1135 rc.opts.logfile = old_logfile
1136 1136 warn("Couldn't start log: %s" % sys.exc_info()[1])
1137 1137 else:
1138 1138 # log input history up to this point, optionally interleaving
1139 1139 # output if requested
1140 1140
1141 1141 if timestamp:
1142 1142 # disable timestamping for the previous history, since we've
1143 1143 # lost those already (no time machine here).
1144 1144 logger.timestamp = False
1145 1145
1146 1146 if log_raw_input:
1147 1147 input_hist = self.shell.input_hist_raw
1148 1148 else:
1149 1149 input_hist = self.shell.input_hist
1150 1150
1151 1151 if log_output:
1152 1152 log_write = logger.log_write
1153 1153 output_hist = self.shell.output_hist
1154 1154 for n in range(1,len(input_hist)-1):
1155 1155 log_write(input_hist[n].rstrip())
1156 1156 if n in output_hist:
1157 1157 log_write(repr(output_hist[n]),'output')
1158 1158 else:
1159 1159 logger.log_write(input_hist[1:])
1160 1160 if timestamp:
1161 1161 # re-enable timestamping
1162 1162 logger.timestamp = True
1163 1163
1164 1164 print ('Activating auto-logging. '
1165 1165 'Current session state plus future input saved.')
1166 1166 logger.logstate()
1167 1167
1168 1168 def magic_logstop(self,parameter_s=''):
1169 1169 """Fully stop logging and close log file.
1170 1170
1171 1171 In order to start logging again, a new %logstart call needs to be made,
1172 1172 possibly (though not necessarily) with a new filename, mode and other
1173 1173 options."""
1174 1174 self.logger.logstop()
1175 1175
1176 1176 def magic_logoff(self,parameter_s=''):
1177 1177 """Temporarily stop logging.
1178 1178
1179 1179 You must have previously started logging."""
1180 1180 self.shell.logger.switch_log(0)
1181 1181
1182 1182 def magic_logon(self,parameter_s=''):
1183 1183 """Restart logging.
1184 1184
1185 1185 This function is for restarting logging which you've temporarily
1186 1186 stopped with %logoff. For starting logging for the first time, you
1187 1187 must use the %logstart function, which allows you to specify an
1188 1188 optional log filename."""
1189 1189
1190 1190 self.shell.logger.switch_log(1)
1191 1191
1192 1192 def magic_logstate(self,parameter_s=''):
1193 1193 """Print the status of the logging system."""
1194 1194
1195 1195 self.shell.logger.logstate()
1196 1196
1197 1197 def magic_pdb(self, parameter_s=''):
1198 1198 """Control the automatic calling of the pdb interactive debugger.
1199 1199
1200 1200 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1201 1201 argument it works as a toggle.
1202 1202
1203 1203 When an exception is triggered, IPython can optionally call the
1204 1204 interactive pdb debugger after the traceback printout. %pdb toggles
1205 1205 this feature on and off.
1206 1206
1207 1207 The initial state of this feature is set in your ipythonrc
1208 1208 configuration file (the variable is called 'pdb').
1209 1209
1210 1210 If you want to just activate the debugger AFTER an exception has fired,
1211 1211 without having to type '%pdb on' and rerunning your code, you can use
1212 1212 the %debug magic."""
1213 1213
1214 1214 par = parameter_s.strip().lower()
1215 1215
1216 1216 if par:
1217 1217 try:
1218 1218 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1219 1219 except KeyError:
1220 1220 print ('Incorrect argument. Use on/1, off/0, '
1221 1221 'or nothing for a toggle.')
1222 1222 return
1223 1223 else:
1224 1224 # toggle
1225 1225 new_pdb = not self.shell.call_pdb
1226 1226
1227 1227 # set on the shell
1228 1228 self.shell.call_pdb = new_pdb
1229 1229 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1230 1230
1231 1231 def magic_debug(self, parameter_s=''):
1232 1232 """Activate the interactive debugger in post-mortem mode.
1233 1233
1234 1234 If an exception has just occurred, this lets you inspect its stack
1235 1235 frames interactively. Note that this will always work only on the last
1236 1236 traceback that occurred, so you must call this quickly after an
1237 1237 exception that you wish to inspect has fired, because if another one
1238 1238 occurs, it clobbers the previous one.
1239 1239
1240 1240 If you want IPython to automatically do this on every exception, see
1241 1241 the %pdb magic for more details.
1242 1242 """
1243 1243
1244 1244 self.shell.debugger(force=True)
1245 1245
1246 1246 def magic_prun(self, parameter_s ='',user_mode=1,
1247 1247 opts=None,arg_lst=None,prog_ns=None):
1248 1248
1249 1249 """Run a statement through the python code profiler.
1250 1250
1251 1251 Usage:\\
1252 1252 %prun [options] statement
1253 1253
1254 1254 The given statement (which doesn't require quote marks) is run via the
1255 1255 python profiler in a manner similar to the profile.run() function.
1256 1256 Namespaces are internally managed to work correctly; profile.run
1257 1257 cannot be used in IPython because it makes certain assumptions about
1258 1258 namespaces which do not hold under IPython.
1259 1259
1260 1260 Options:
1261 1261
1262 1262 -l <limit>: you can place restrictions on what or how much of the
1263 1263 profile gets printed. The limit value can be:
1264 1264
1265 1265 * A string: only information for function names containing this string
1266 1266 is printed.
1267 1267
1268 1268 * An integer: only these many lines are printed.
1269 1269
1270 1270 * A float (between 0 and 1): this fraction of the report is printed
1271 1271 (for example, use a limit of 0.4 to see the topmost 40% only).
1272 1272
1273 1273 You can combine several limits with repeated use of the option. For
1274 1274 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1275 1275 information about class constructors.
1276 1276
1277 1277 -r: return the pstats.Stats object generated by the profiling. This
1278 1278 object has all the information about the profile in it, and you can
1279 1279 later use it for further analysis or in other functions.
1280 1280
1281 1281 -s <key>: sort profile by given key. You can provide more than one key
1282 1282 by using the option several times: '-s key1 -s key2 -s key3...'. The
1283 1283 default sorting key is 'time'.
1284 1284
1285 1285 The following is copied verbatim from the profile documentation
1286 1286 referenced below:
1287 1287
1288 1288 When more than one key is provided, additional keys are used as
1289 1289 secondary criteria when the there is equality in all keys selected
1290 1290 before them.
1291 1291
1292 1292 Abbreviations can be used for any key names, as long as the
1293 1293 abbreviation is unambiguous. The following are the keys currently
1294 1294 defined:
1295 1295
1296 1296 Valid Arg Meaning\\
1297 1297 "calls" call count\\
1298 1298 "cumulative" cumulative time\\
1299 1299 "file" file name\\
1300 1300 "module" file name\\
1301 1301 "pcalls" primitive call count\\
1302 1302 "line" line number\\
1303 1303 "name" function name\\
1304 1304 "nfl" name/file/line\\
1305 1305 "stdname" standard name\\
1306 1306 "time" internal time
1307 1307
1308 1308 Note that all sorts on statistics are in descending order (placing
1309 1309 most time consuming items first), where as name, file, and line number
1310 1310 searches are in ascending order (i.e., alphabetical). The subtle
1311 1311 distinction between "nfl" and "stdname" is that the standard name is a
1312 1312 sort of the name as printed, which means that the embedded line
1313 1313 numbers get compared in an odd way. For example, lines 3, 20, and 40
1314 1314 would (if the file names were the same) appear in the string order
1315 1315 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1316 1316 line numbers. In fact, sort_stats("nfl") is the same as
1317 1317 sort_stats("name", "file", "line").
1318 1318
1319 1319 -T <filename>: save profile results as shown on screen to a text
1320 1320 file. The profile is still shown on screen.
1321 1321
1322 1322 -D <filename>: save (via dump_stats) profile statistics to given
1323 1323 filename. This data is in a format understod by the pstats module, and
1324 1324 is generated by a call to the dump_stats() method of profile
1325 1325 objects. The profile is still shown on screen.
1326 1326
1327 1327 If you want to run complete programs under the profiler's control, use
1328 1328 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1329 1329 contains profiler specific options as described here.
1330 1330
1331 1331 You can read the complete documentation for the profile module with:\\
1332 1332 In [1]: import profile; profile.help() """
1333 1333
1334 1334 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1335 1335 # protect user quote marks
1336 1336 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1337 1337
1338 1338 if user_mode: # regular user call
1339 1339 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1340 1340 list_all=1)
1341 1341 namespace = self.shell.user_ns
1342 1342 else: # called to run a program by %run -p
1343 1343 try:
1344 1344 filename = get_py_filename(arg_lst[0])
1345 1345 except IOError,msg:
1346 1346 error(msg)
1347 1347 return
1348 1348
1349 1349 arg_str = 'execfile(filename,prog_ns)'
1350 1350 namespace = locals()
1351 1351
1352 1352 opts.merge(opts_def)
1353 1353
1354 1354 prof = profile.Profile()
1355 1355 try:
1356 1356 prof = prof.runctx(arg_str,namespace,namespace)
1357 1357 sys_exit = ''
1358 1358 except SystemExit:
1359 1359 sys_exit = """*** SystemExit exception caught in code being profiled."""
1360 1360
1361 1361 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1362 1362
1363 1363 lims = opts.l
1364 1364 if lims:
1365 1365 lims = [] # rebuild lims with ints/floats/strings
1366 1366 for lim in opts.l:
1367 1367 try:
1368 1368 lims.append(int(lim))
1369 1369 except ValueError:
1370 1370 try:
1371 1371 lims.append(float(lim))
1372 1372 except ValueError:
1373 1373 lims.append(lim)
1374 1374
1375 1375 # Trap output.
1376 1376 stdout_trap = StringIO()
1377 1377
1378 1378 if hasattr(stats,'stream'):
1379 1379 # In newer versions of python, the stats object has a 'stream'
1380 1380 # attribute to write into.
1381 1381 stats.stream = stdout_trap
1382 1382 stats.print_stats(*lims)
1383 1383 else:
1384 1384 # For older versions, we manually redirect stdout during printing
1385 1385 sys_stdout = sys.stdout
1386 1386 try:
1387 1387 sys.stdout = stdout_trap
1388 1388 stats.print_stats(*lims)
1389 1389 finally:
1390 1390 sys.stdout = sys_stdout
1391 1391
1392 1392 output = stdout_trap.getvalue()
1393 1393 output = output.rstrip()
1394 1394
1395 1395 page(output,screen_lines=self.shell.rc.screen_length)
1396 1396 print sys_exit,
1397 1397
1398 1398 dump_file = opts.D[0]
1399 1399 text_file = opts.T[0]
1400 1400 if dump_file:
1401 1401 prof.dump_stats(dump_file)
1402 1402 print '\n*** Profile stats marshalled to file',\
1403 1403 `dump_file`+'.',sys_exit
1404 1404 if text_file:
1405 1405 pfile = file(text_file,'w')
1406 1406 pfile.write(output)
1407 1407 pfile.close()
1408 1408 print '\n*** Profile printout saved to text file',\
1409 1409 `text_file`+'.',sys_exit
1410 1410
1411 1411 if opts.has_key('r'):
1412 1412 return stats
1413 1413 else:
1414 1414 return None
1415 1415
1416 1416 def magic_run(self, parameter_s ='',runner=None):
1417 1417 """Run the named file inside IPython as a program.
1418 1418
1419 1419 Usage:\\
1420 1420 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1421 1421
1422 1422 Parameters after the filename are passed as command-line arguments to
1423 1423 the program (put in sys.argv). Then, control returns to IPython's
1424 1424 prompt.
1425 1425
1426 1426 This is similar to running at a system prompt:\\
1427 1427 $ python file args\\
1428 1428 but with the advantage of giving you IPython's tracebacks, and of
1429 1429 loading all variables into your interactive namespace for further use
1430 1430 (unless -p is used, see below).
1431 1431
1432 1432 The file is executed in a namespace initially consisting only of
1433 1433 __name__=='__main__' and sys.argv constructed as indicated. It thus
1434 1434 sees its environment as if it were being run as a stand-alone program
1435 1435 (except for sharing global objects such as previously imported
1436 1436 modules). But after execution, the IPython interactive namespace gets
1437 1437 updated with all variables defined in the program (except for __name__
1438 1438 and sys.argv). This allows for very convenient loading of code for
1439 1439 interactive work, while giving each program a 'clean sheet' to run in.
1440 1440
1441 1441 Options:
1442 1442
1443 1443 -n: __name__ is NOT set to '__main__', but to the running file's name
1444 1444 without extension (as python does under import). This allows running
1445 1445 scripts and reloading the definitions in them without calling code
1446 1446 protected by an ' if __name__ == "__main__" ' clause.
1447 1447
1448 1448 -i: run the file in IPython's namespace instead of an empty one. This
1449 1449 is useful if you are experimenting with code written in a text editor
1450 1450 which depends on variables defined interactively.
1451 1451
1452 1452 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1453 1453 being run. This is particularly useful if IPython is being used to
1454 1454 run unittests, which always exit with a sys.exit() call. In such
1455 1455 cases you are interested in the output of the test results, not in
1456 1456 seeing a traceback of the unittest module.
1457 1457
1458 1458 -t: print timing information at the end of the run. IPython will give
1459 1459 you an estimated CPU time consumption for your script, which under
1460 1460 Unix uses the resource module to avoid the wraparound problems of
1461 1461 time.clock(). Under Unix, an estimate of time spent on system tasks
1462 1462 is also given (for Windows platforms this is reported as 0.0).
1463 1463
1464 1464 If -t is given, an additional -N<N> option can be given, where <N>
1465 1465 must be an integer indicating how many times you want the script to
1466 1466 run. The final timing report will include total and per run results.
1467 1467
1468 1468 For example (testing the script uniq_stable.py):
1469 1469
1470 1470 In [1]: run -t uniq_stable
1471 1471
1472 1472 IPython CPU timings (estimated):\\
1473 1473 User : 0.19597 s.\\
1474 1474 System: 0.0 s.\\
1475 1475
1476 1476 In [2]: run -t -N5 uniq_stable
1477 1477
1478 1478 IPython CPU timings (estimated):\\
1479 1479 Total runs performed: 5\\
1480 1480 Times : Total Per run\\
1481 1481 User : 0.910862 s, 0.1821724 s.\\
1482 1482 System: 0.0 s, 0.0 s.
1483 1483
1484 1484 -d: run your program under the control of pdb, the Python debugger.
1485 1485 This allows you to execute your program step by step, watch variables,
1486 1486 etc. Internally, what IPython does is similar to calling:
1487 1487
1488 1488 pdb.run('execfile("YOURFILENAME")')
1489 1489
1490 1490 with a breakpoint set on line 1 of your file. You can change the line
1491 1491 number for this automatic breakpoint to be <N> by using the -bN option
1492 1492 (where N must be an integer). For example:
1493 1493
1494 1494 %run -d -b40 myscript
1495 1495
1496 1496 will set the first breakpoint at line 40 in myscript.py. Note that
1497 1497 the first breakpoint must be set on a line which actually does
1498 1498 something (not a comment or docstring) for it to stop execution.
1499 1499
1500 1500 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1501 1501 first enter 'c' (without qoutes) to start execution up to the first
1502 1502 breakpoint.
1503 1503
1504 1504 Entering 'help' gives information about the use of the debugger. You
1505 1505 can easily see pdb's full documentation with "import pdb;pdb.help()"
1506 1506 at a prompt.
1507 1507
1508 1508 -p: run program under the control of the Python profiler module (which
1509 1509 prints a detailed report of execution times, function calls, etc).
1510 1510
1511 1511 You can pass other options after -p which affect the behavior of the
1512 1512 profiler itself. See the docs for %prun for details.
1513 1513
1514 1514 In this mode, the program's variables do NOT propagate back to the
1515 1515 IPython interactive namespace (because they remain in the namespace
1516 1516 where the profiler executes them).
1517 1517
1518 1518 Internally this triggers a call to %prun, see its documentation for
1519 1519 details on the options available specifically for profiling.
1520 1520
1521 1521 There is one special usage for which the text above doesn't apply:
1522 1522 if the filename ends with .ipy, the file is run as ipython script,
1523 1523 just as if the commands were written on IPython prompt.
1524 1524 """
1525 1525
1526 1526 # get arguments and set sys.argv for program to be run.
1527 1527 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1528 1528 mode='list',list_all=1)
1529 1529
1530 1530 try:
1531 1531 filename = get_py_filename(arg_lst[0])
1532 1532 except IndexError:
1533 1533 warn('you must provide at least a filename.')
1534 1534 print '\n%run:\n',OInspect.getdoc(self.magic_run)
1535 1535 return
1536 1536 except IOError,msg:
1537 1537 error(msg)
1538 1538 return
1539 1539
1540 1540 if filename.lower().endswith('.ipy'):
1541 1541 self.api.runlines(open(filename).read())
1542 1542 return
1543 1543
1544 1544 # Control the response to exit() calls made by the script being run
1545 1545 exit_ignore = opts.has_key('e')
1546 1546
1547 1547 # Make sure that the running script gets a proper sys.argv as if it
1548 1548 # were run from a system shell.
1549 1549 save_argv = sys.argv # save it for later restoring
1550 1550 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1551 1551
1552 1552 if opts.has_key('i'):
1553 1553 # Run in user's interactive namespace
1554 1554 prog_ns = self.shell.user_ns
1555 1555 __name__save = self.shell.user_ns['__name__']
1556 1556 prog_ns['__name__'] = '__main__'
1557 1557 main_mod = FakeModule(prog_ns)
1558 1558 else:
1559 1559 # Run in a fresh, empty namespace
1560 1560 if opts.has_key('n'):
1561 1561 name = os.path.splitext(os.path.basename(filename))[0]
1562 1562 else:
1563 1563 name = '__main__'
1564 1564 main_mod = FakeModule()
1565 1565 prog_ns = main_mod.__dict__
1566 1566 prog_ns['__name__'] = name
1567 1567 # The shell MUST hold a reference to main_mod so after %run exits,
1568 1568 # the python deletion mechanism doesn't zero it out (leaving
1569 1569 # dangling references)
1570 1570 self.shell._user_main_modules.append(main_mod)
1571 1571
1572 1572 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1573 1573 # set the __file__ global in the script's namespace
1574 1574 prog_ns['__file__'] = filename
1575 1575
1576 1576 # pickle fix. See iplib for an explanation. But we need to make sure
1577 1577 # that, if we overwrite __main__, we replace it at the end
1578 1578 if prog_ns['__name__'] == '__main__':
1579 1579 restore_main = sys.modules['__main__']
1580 1580 else:
1581 1581 restore_main = False
1582 1582
1583 1583 sys.modules[prog_ns['__name__']] = main_mod
1584 1584
1585 1585 stats = None
1586 1586 try:
1587 1587 self.shell.savehist()
1588 1588
1589 1589 if opts.has_key('p'):
1590 1590 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1591 1591 else:
1592 1592 if opts.has_key('d'):
1593 1593 deb = Debugger.Pdb(self.shell.rc.colors)
1594 1594 # reset Breakpoint state, which is moronically kept
1595 1595 # in a class
1596 1596 bdb.Breakpoint.next = 1
1597 1597 bdb.Breakpoint.bplist = {}
1598 1598 bdb.Breakpoint.bpbynumber = [None]
1599 1599 # Set an initial breakpoint to stop execution
1600 1600 maxtries = 10
1601 1601 bp = int(opts.get('b',[1])[0])
1602 1602 checkline = deb.checkline(filename,bp)
1603 1603 if not checkline:
1604 1604 for bp in range(bp+1,bp+maxtries+1):
1605 1605 if deb.checkline(filename,bp):
1606 1606 break
1607 1607 else:
1608 1608 msg = ("\nI failed to find a valid line to set "
1609 1609 "a breakpoint\n"
1610 1610 "after trying up to line: %s.\n"
1611 1611 "Please set a valid breakpoint manually "
1612 1612 "with the -b option." % bp)
1613 1613 error(msg)
1614 1614 return
1615 1615 # if we find a good linenumber, set the breakpoint
1616 1616 deb.do_break('%s:%s' % (filename,bp))
1617 1617 # Start file run
1618 1618 print "NOTE: Enter 'c' at the",
1619 1619 print "%s prompt to start your script." % deb.prompt
1620 1620 try:
1621 1621 deb.run('execfile("%s")' % filename,prog_ns)
1622 1622
1623 1623 except:
1624 1624 etype, value, tb = sys.exc_info()
1625 1625 # Skip three frames in the traceback: the %run one,
1626 1626 # one inside bdb.py, and the command-line typed by the
1627 1627 # user (run by exec in pdb itself).
1628 1628 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1629 1629 else:
1630 1630 if runner is None:
1631 1631 runner = self.shell.safe_execfile
1632 1632 if opts.has_key('t'):
1633 1633 # timed execution
1634 1634 try:
1635 1635 nruns = int(opts['N'][0])
1636 1636 if nruns < 1:
1637 1637 error('Number of runs must be >=1')
1638 1638 return
1639 1639 except (KeyError):
1640 1640 nruns = 1
1641 1641 if nruns == 1:
1642 1642 t0 = clock2()
1643 1643 runner(filename,prog_ns,prog_ns,
1644 1644 exit_ignore=exit_ignore)
1645 1645 t1 = clock2()
1646 1646 t_usr = t1[0]-t0[0]
1647 1647 t_sys = t1[1]-t1[1]
1648 1648 print "\nIPython CPU timings (estimated):"
1649 1649 print " User : %10s s." % t_usr
1650 1650 print " System: %10s s." % t_sys
1651 1651 else:
1652 1652 runs = range(nruns)
1653 1653 t0 = clock2()
1654 1654 for nr in runs:
1655 1655 runner(filename,prog_ns,prog_ns,
1656 1656 exit_ignore=exit_ignore)
1657 1657 t1 = clock2()
1658 1658 t_usr = t1[0]-t0[0]
1659 1659 t_sys = t1[1]-t1[1]
1660 1660 print "\nIPython CPU timings (estimated):"
1661 1661 print "Total runs performed:",nruns
1662 1662 print " Times : %10s %10s" % ('Total','Per run')
1663 1663 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1664 1664 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1665 1665
1666 1666 else:
1667 1667 # regular execution
1668 1668 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1669 1669 if opts.has_key('i'):
1670 1670 self.shell.user_ns['__name__'] = __name__save
1671 1671 else:
1672 1672 # update IPython interactive namespace
1673 1673 del prog_ns['__name__']
1674 1674 self.shell.user_ns.update(prog_ns)
1675 1675 finally:
1676 1676 sys.argv = save_argv
1677 1677 if restore_main:
1678 1678 sys.modules['__main__'] = restore_main
1679 1679 self.shell.reloadhist()
1680 1680
1681 1681 return stats
1682 1682
1683 1683 def magic_runlog(self, parameter_s =''):
1684 1684 """Run files as logs.
1685 1685
1686 1686 Usage:\\
1687 1687 %runlog file1 file2 ...
1688 1688
1689 1689 Run the named files (treating them as log files) in sequence inside
1690 1690 the interpreter, and return to the prompt. This is much slower than
1691 1691 %run because each line is executed in a try/except block, but it
1692 1692 allows running files with syntax errors in them.
1693 1693
1694 1694 Normally IPython will guess when a file is one of its own logfiles, so
1695 1695 you can typically use %run even for logs. This shorthand allows you to
1696 1696 force any file to be treated as a log file."""
1697 1697
1698 1698 for f in parameter_s.split():
1699 1699 self.shell.safe_execfile(f,self.shell.user_ns,
1700 1700 self.shell.user_ns,islog=1)
1701 1701
1702 1702 def magic_timeit(self, parameter_s =''):
1703 1703 """Time execution of a Python statement or expression
1704 1704
1705 1705 Usage:\\
1706 1706 %timeit [-n<N> -r<R> [-t|-c]] statement
1707 1707
1708 1708 Time execution of a Python statement or expression using the timeit
1709 1709 module.
1710 1710
1711 1711 Options:
1712 1712 -n<N>: execute the given statement <N> times in a loop. If this value
1713 1713 is not given, a fitting value is chosen.
1714 1714
1715 1715 -r<R>: repeat the loop iteration <R> times and take the best result.
1716 1716 Default: 3
1717 1717
1718 1718 -t: use time.time to measure the time, which is the default on Unix.
1719 1719 This function measures wall time.
1720 1720
1721 1721 -c: use time.clock to measure the time, which is the default on
1722 1722 Windows and measures wall time. On Unix, resource.getrusage is used
1723 1723 instead and returns the CPU user time.
1724 1724
1725 1725 -p<P>: use a precision of <P> digits to display the timing result.
1726 1726 Default: 3
1727 1727
1728 1728
1729 1729 Examples:\\
1730 1730 In [1]: %timeit pass
1731 1731 10000000 loops, best of 3: 53.3 ns per loop
1732 1732
1733 1733 In [2]: u = None
1734 1734
1735 1735 In [3]: %timeit u is None
1736 1736 10000000 loops, best of 3: 184 ns per loop
1737 1737
1738 1738 In [4]: %timeit -r 4 u == None
1739 1739 1000000 loops, best of 4: 242 ns per loop
1740 1740
1741 1741 In [5]: import time
1742 1742
1743 1743 In [6]: %timeit -n1 time.sleep(2)
1744 1744 1 loops, best of 3: 2 s per loop
1745 1745
1746 1746
1747 1747 The times reported by %timeit will be slightly higher than those
1748 1748 reported by the timeit.py script when variables are accessed. This is
1749 1749 due to the fact that %timeit executes the statement in the namespace
1750 1750 of the shell, compared with timeit.py, which uses a single setup
1751 1751 statement to import function or create variables. Generally, the bias
1752 1752 does not matter as long as results from timeit.py are not mixed with
1753 1753 those from %timeit."""
1754 1754
1755 1755 import timeit
1756 1756 import math
1757 1757
1758 1758 units = ["s", "ms", "\xc2\xb5s", "ns"]
1759 1759 scaling = [1, 1e3, 1e6, 1e9]
1760 1760
1761 1761 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1762 1762 posix=False)
1763 1763 if stmt == "":
1764 1764 return
1765 1765 timefunc = timeit.default_timer
1766 1766 number = int(getattr(opts, "n", 0))
1767 1767 repeat = int(getattr(opts, "r", timeit.default_repeat))
1768 1768 precision = int(getattr(opts, "p", 3))
1769 1769 if hasattr(opts, "t"):
1770 1770 timefunc = time.time
1771 1771 if hasattr(opts, "c"):
1772 1772 timefunc = clock
1773 1773
1774 1774 timer = timeit.Timer(timer=timefunc)
1775 1775 # this code has tight coupling to the inner workings of timeit.Timer,
1776 1776 # but is there a better way to achieve that the code stmt has access
1777 1777 # to the shell namespace?
1778 1778
1779 1779 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1780 1780 'setup': "pass"}
1781 1781 # Track compilation time so it can be reported if too long
1782 1782 # Minimum time above which compilation time will be reported
1783 1783 tc_min = 0.1
1784 1784
1785 1785 t0 = clock()
1786 1786 code = compile(src, "<magic-timeit>", "exec")
1787 1787 tc = clock()-t0
1788 1788
1789 1789 ns = {}
1790 1790 exec code in self.shell.user_ns, ns
1791 1791 timer.inner = ns["inner"]
1792 1792
1793 1793 if number == 0:
1794 1794 # determine number so that 0.2 <= total time < 2.0
1795 1795 number = 1
1796 1796 for i in range(1, 10):
1797 1797 number *= 10
1798 1798 if timer.timeit(number) >= 0.2:
1799 1799 break
1800 1800
1801 1801 best = min(timer.repeat(repeat, number)) / number
1802 1802
1803 1803 if best > 0.0:
1804 1804 order = min(-int(math.floor(math.log10(best)) // 3), 3)
1805 1805 else:
1806 1806 order = 3
1807 1807 print "%d loops, best of %d: %.*g %s per loop" % (number, repeat,
1808 1808 precision,
1809 1809 best * scaling[order],
1810 1810 units[order])
1811 1811 if tc > tc_min:
1812 1812 print "Compiler time: %.2f s" % tc
1813 1813
1814 1814 def magic_time(self,parameter_s = ''):
1815 1815 """Time execution of a Python statement or expression.
1816 1816
1817 1817 The CPU and wall clock times are printed, and the value of the
1818 1818 expression (if any) is returned. Note that under Win32, system time
1819 1819 is always reported as 0, since it can not be measured.
1820 1820
1821 1821 This function provides very basic timing functionality. In Python
1822 1822 2.3, the timeit module offers more control and sophistication, so this
1823 1823 could be rewritten to use it (patches welcome).
1824 1824
1825 1825 Some examples:
1826 1826
1827 1827 In [1]: time 2**128
1828 1828 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1829 1829 Wall time: 0.00
1830 1830 Out[1]: 340282366920938463463374607431768211456L
1831 1831
1832 1832 In [2]: n = 1000000
1833 1833
1834 1834 In [3]: time sum(range(n))
1835 1835 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1836 1836 Wall time: 1.37
1837 1837 Out[3]: 499999500000L
1838 1838
1839 1839 In [4]: time print 'hello world'
1840 1840 hello world
1841 1841 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1842 1842 Wall time: 0.00
1843 1843
1844 1844 Note that the time needed by Python to compile the given expression
1845 1845 will be reported if it is more than 0.1s. In this example, the
1846 1846 actual exponentiation is done by Python at compilation time, so while
1847 1847 the expression can take a noticeable amount of time to compute, that
1848 1848 time is purely due to the compilation:
1849 1849
1850 1850 In [5]: time 3**9999;
1851 1851 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1852 1852 Wall time: 0.00 s
1853 1853
1854 1854 In [6]: time 3**999999;
1855 1855 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1856 1856 Wall time: 0.00 s
1857 1857 Compiler : 0.78 s
1858 1858 """
1859 1859
1860 1860 # fail immediately if the given expression can't be compiled
1861 1861
1862 1862 expr = self.shell.prefilter(parameter_s,False)
1863 1863
1864 1864 # Minimum time above which compilation time will be reported
1865 1865 tc_min = 0.1
1866 1866
1867 1867 try:
1868 1868 mode = 'eval'
1869 1869 t0 = clock()
1870 1870 code = compile(expr,'<timed eval>',mode)
1871 1871 tc = clock()-t0
1872 1872 except SyntaxError:
1873 1873 mode = 'exec'
1874 1874 t0 = clock()
1875 1875 code = compile(expr,'<timed exec>',mode)
1876 1876 tc = clock()-t0
1877 1877 # skew measurement as little as possible
1878 1878 glob = self.shell.user_ns
1879 1879 clk = clock2
1880 1880 wtime = time.time
1881 1881 # time execution
1882 1882 wall_st = wtime()
1883 1883 if mode=='eval':
1884 1884 st = clk()
1885 1885 out = eval(code,glob)
1886 1886 end = clk()
1887 1887 else:
1888 1888 st = clk()
1889 1889 exec code in glob
1890 1890 end = clk()
1891 1891 out = None
1892 1892 wall_end = wtime()
1893 1893 # Compute actual times and report
1894 1894 wall_time = wall_end-wall_st
1895 1895 cpu_user = end[0]-st[0]
1896 1896 cpu_sys = end[1]-st[1]
1897 1897 cpu_tot = cpu_user+cpu_sys
1898 1898 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1899 1899 (cpu_user,cpu_sys,cpu_tot)
1900 1900 print "Wall time: %.2f s" % wall_time
1901 1901 if tc > tc_min:
1902 1902 print "Compiler : %.2f s" % tc
1903 1903 return out
1904 1904
1905 1905 def magic_macro(self,parameter_s = ''):
1906 1906 """Define a set of input lines as a macro for future re-execution.
1907 1907
1908 1908 Usage:\\
1909 1909 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
1910 1910
1911 1911 Options:
1912 1912
1913 1913 -r: use 'raw' input. By default, the 'processed' history is used,
1914 1914 so that magics are loaded in their transformed version to valid
1915 1915 Python. If this option is given, the raw input as typed as the
1916 1916 command line is used instead.
1917 1917
1918 1918 This will define a global variable called `name` which is a string
1919 1919 made of joining the slices and lines you specify (n1,n2,... numbers
1920 1920 above) from your input history into a single string. This variable
1921 1921 acts like an automatic function which re-executes those lines as if
1922 1922 you had typed them. You just type 'name' at the prompt and the code
1923 1923 executes.
1924 1924
1925 1925 The notation for indicating number ranges is: n1-n2 means 'use line
1926 1926 numbers n1,...n2' (the endpoint is included). That is, '5-7' means
1927 1927 using the lines numbered 5,6 and 7.
1928 1928
1929 1929 Note: as a 'hidden' feature, you can also use traditional python slice
1930 1930 notation, where N:M means numbers N through M-1.
1931 1931
1932 1932 For example, if your history contains (%hist prints it):
1933 1933
1934 1934 44: x=1\\
1935 1935 45: y=3\\
1936 1936 46: z=x+y\\
1937 1937 47: print x\\
1938 1938 48: a=5\\
1939 1939 49: print 'x',x,'y',y\\
1940 1940
1941 1941 you can create a macro with lines 44 through 47 (included) and line 49
1942 1942 called my_macro with:
1943 1943
1944 1944 In [51]: %macro my_macro 44-47 49
1945 1945
1946 1946 Now, typing `my_macro` (without quotes) will re-execute all this code
1947 1947 in one pass.
1948 1948
1949 1949 You don't need to give the line-numbers in order, and any given line
1950 1950 number can appear multiple times. You can assemble macros with any
1951 1951 lines from your input history in any order.
1952 1952
1953 1953 The macro is a simple object which holds its value in an attribute,
1954 1954 but IPython's display system checks for macros and executes them as
1955 1955 code instead of printing them when you type their name.
1956 1956
1957 1957 You can view a macro's contents by explicitly printing it with:
1958 1958
1959 1959 'print macro_name'.
1960 1960
1961 1961 For one-off cases which DON'T contain magic function calls in them you
1962 1962 can obtain similar results by explicitly executing slices from your
1963 1963 input history with:
1964 1964
1965 1965 In [60]: exec In[44:48]+In[49]"""
1966 1966
1967 1967 opts,args = self.parse_options(parameter_s,'r',mode='list')
1968 1968 if not args:
1969 1969 macs = [k for k,v in self.shell.user_ns.items() if isinstance(v, Macro)]
1970 1970 macs.sort()
1971 1971 return macs
1972 1972 if len(args) == 1:
1973 1973 raise UsageError(
1974 1974 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
1975 1975 name,ranges = args[0], args[1:]
1976 1976
1977 1977 #print 'rng',ranges # dbg
1978 1978 lines = self.extract_input_slices(ranges,opts.has_key('r'))
1979 1979 macro = Macro(lines)
1980 1980 self.shell.user_ns.update({name:macro})
1981 1981 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
1982 1982 print 'Macro contents:'
1983 1983 print macro,
1984 1984
1985 1985 def magic_save(self,parameter_s = ''):
1986 1986 """Save a set of lines to a given filename.
1987 1987
1988 1988 Usage:\\
1989 1989 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
1990 1990
1991 1991 Options:
1992 1992
1993 1993 -r: use 'raw' input. By default, the 'processed' history is used,
1994 1994 so that magics are loaded in their transformed version to valid
1995 1995 Python. If this option is given, the raw input as typed as the
1996 1996 command line is used instead.
1997 1997
1998 1998 This function uses the same syntax as %macro for line extraction, but
1999 1999 instead of creating a macro it saves the resulting string to the
2000 2000 filename you specify.
2001 2001
2002 2002 It adds a '.py' extension to the file if you don't do so yourself, and
2003 2003 it asks for confirmation before overwriting existing files."""
2004 2004
2005 2005 opts,args = self.parse_options(parameter_s,'r',mode='list')
2006 2006 fname,ranges = args[0], args[1:]
2007 2007 if not fname.endswith('.py'):
2008 2008 fname += '.py'
2009 2009 if os.path.isfile(fname):
2010 2010 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
2011 2011 if ans.lower() not in ['y','yes']:
2012 2012 print 'Operation cancelled.'
2013 2013 return
2014 2014 cmds = ''.join(self.extract_input_slices(ranges,opts.has_key('r')))
2015 2015 f = file(fname,'w')
2016 2016 f.write(cmds)
2017 2017 f.close()
2018 2018 print 'The following commands were written to file `%s`:' % fname
2019 2019 print cmds
2020 2020
2021 2021 def _edit_macro(self,mname,macro):
2022 2022 """open an editor with the macro data in a file"""
2023 2023 filename = self.shell.mktempfile(macro.value)
2024 2024 self.shell.hooks.editor(filename)
2025 2025
2026 2026 # and make a new macro object, to replace the old one
2027 2027 mfile = open(filename)
2028 2028 mvalue = mfile.read()
2029 2029 mfile.close()
2030 2030 self.shell.user_ns[mname] = Macro(mvalue)
2031 2031
2032 2032 def magic_ed(self,parameter_s=''):
2033 2033 """Alias to %edit."""
2034 2034 return self.magic_edit(parameter_s)
2035 2035
2036 2036 def magic_edit(self,parameter_s='',last_call=['','']):
2037 2037 """Bring up an editor and execute the resulting code.
2038 2038
2039 2039 Usage:
2040 2040 %edit [options] [args]
2041 2041
2042 2042 %edit runs IPython's editor hook. The default version of this hook is
2043 2043 set to call the __IPYTHON__.rc.editor command. This is read from your
2044 2044 environment variable $EDITOR. If this isn't found, it will default to
2045 2045 vi under Linux/Unix and to notepad under Windows. See the end of this
2046 2046 docstring for how to change the editor hook.
2047 2047
2048 2048 You can also set the value of this editor via the command line option
2049 2049 '-editor' or in your ipythonrc file. This is useful if you wish to use
2050 2050 specifically for IPython an editor different from your typical default
2051 2051 (and for Windows users who typically don't set environment variables).
2052 2052
2053 2053 This command allows you to conveniently edit multi-line code right in
2054 2054 your IPython session.
2055 2055
2056 2056 If called without arguments, %edit opens up an empty editor with a
2057 2057 temporary file and will execute the contents of this file when you
2058 2058 close it (don't forget to save it!).
2059 2059
2060 2060
2061 2061 Options:
2062 2062
2063 2063 -n <number>: open the editor at a specified line number. By default,
2064 2064 the IPython editor hook uses the unix syntax 'editor +N filename', but
2065 2065 you can configure this by providing your own modified hook if your
2066 2066 favorite editor supports line-number specifications with a different
2067 2067 syntax.
2068 2068
2069 2069 -p: this will call the editor with the same data as the previous time
2070 2070 it was used, regardless of how long ago (in your current session) it
2071 2071 was.
2072 2072
2073 2073 -r: use 'raw' input. This option only applies to input taken from the
2074 2074 user's history. By default, the 'processed' history is used, so that
2075 2075 magics are loaded in their transformed version to valid Python. If
2076 2076 this option is given, the raw input as typed as the command line is
2077 2077 used instead. When you exit the editor, it will be executed by
2078 2078 IPython's own processor.
2079 2079
2080 2080 -x: do not execute the edited code immediately upon exit. This is
2081 2081 mainly useful if you are editing programs which need to be called with
2082 2082 command line arguments, which you can then do using %run.
2083 2083
2084 2084
2085 2085 Arguments:
2086 2086
2087 2087 If arguments are given, the following possibilites exist:
2088 2088
2089 2089 - The arguments are numbers or pairs of colon-separated numbers (like
2090 2090 1 4:8 9). These are interpreted as lines of previous input to be
2091 2091 loaded into the editor. The syntax is the same of the %macro command.
2092 2092
2093 2093 - If the argument doesn't start with a number, it is evaluated as a
2094 2094 variable and its contents loaded into the editor. You can thus edit
2095 2095 any string which contains python code (including the result of
2096 2096 previous edits).
2097 2097
2098 2098 - If the argument is the name of an object (other than a string),
2099 2099 IPython will try to locate the file where it was defined and open the
2100 2100 editor at the point where it is defined. You can use `%edit function`
2101 2101 to load an editor exactly at the point where 'function' is defined,
2102 2102 edit it and have the file be executed automatically.
2103 2103
2104 2104 If the object is a macro (see %macro for details), this opens up your
2105 2105 specified editor with a temporary file containing the macro's data.
2106 2106 Upon exit, the macro is reloaded with the contents of the file.
2107 2107
2108 2108 Note: opening at an exact line is only supported under Unix, and some
2109 2109 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2110 2110 '+NUMBER' parameter necessary for this feature. Good editors like
2111 2111 (X)Emacs, vi, jed, pico and joe all do.
2112 2112
2113 2113 - If the argument is not found as a variable, IPython will look for a
2114 2114 file with that name (adding .py if necessary) and load it into the
2115 2115 editor. It will execute its contents with execfile() when you exit,
2116 2116 loading any code in the file into your interactive namespace.
2117 2117
2118 2118 After executing your code, %edit will return as output the code you
2119 2119 typed in the editor (except when it was an existing file). This way
2120 2120 you can reload the code in further invocations of %edit as a variable,
2121 2121 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2122 2122 the output.
2123 2123
2124 2124 Note that %edit is also available through the alias %ed.
2125 2125
2126 2126 This is an example of creating a simple function inside the editor and
2127 2127 then modifying it. First, start up the editor:
2128 2128
2129 2129 In [1]: ed\\
2130 2130 Editing... done. Executing edited code...\\
2131 2131 Out[1]: 'def foo():\\n print "foo() was defined in an editing session"\\n'
2132 2132
2133 2133 We can then call the function foo():
2134 2134
2135 2135 In [2]: foo()\\
2136 2136 foo() was defined in an editing session
2137 2137
2138 2138 Now we edit foo. IPython automatically loads the editor with the
2139 2139 (temporary) file where foo() was previously defined:
2140 2140
2141 2141 In [3]: ed foo\\
2142 2142 Editing... done. Executing edited code...
2143 2143
2144 2144 And if we call foo() again we get the modified version:
2145 2145
2146 2146 In [4]: foo()\\
2147 2147 foo() has now been changed!
2148 2148
2149 2149 Here is an example of how to edit a code snippet successive
2150 2150 times. First we call the editor:
2151 2151
2152 2152 In [8]: ed\\
2153 2153 Editing... done. Executing edited code...\\
2154 2154 hello\\
2155 2155 Out[8]: "print 'hello'\\n"
2156 2156
2157 2157 Now we call it again with the previous output (stored in _):
2158 2158
2159 2159 In [9]: ed _\\
2160 2160 Editing... done. Executing edited code...\\
2161 2161 hello world\\
2162 2162 Out[9]: "print 'hello world'\\n"
2163 2163
2164 2164 Now we call it with the output #8 (stored in _8, also as Out[8]):
2165 2165
2166 2166 In [10]: ed _8\\
2167 2167 Editing... done. Executing edited code...\\
2168 2168 hello again\\
2169 2169 Out[10]: "print 'hello again'\\n"
2170 2170
2171 2171
2172 2172 Changing the default editor hook:
2173 2173
2174 2174 If you wish to write your own editor hook, you can put it in a
2175 2175 configuration file which you load at startup time. The default hook
2176 2176 is defined in the IPython.hooks module, and you can use that as a
2177 2177 starting example for further modifications. That file also has
2178 2178 general instructions on how to set a new hook for use once you've
2179 2179 defined it."""
2180 2180
2181 2181 # FIXME: This function has become a convoluted mess. It needs a
2182 2182 # ground-up rewrite with clean, simple logic.
2183 2183
2184 2184 def make_filename(arg):
2185 2185 "Make a filename from the given args"
2186 2186 try:
2187 2187 filename = get_py_filename(arg)
2188 2188 except IOError:
2189 2189 if args.endswith('.py'):
2190 2190 filename = arg
2191 2191 else:
2192 2192 filename = None
2193 2193 return filename
2194 2194
2195 2195 # custom exceptions
2196 2196 class DataIsObject(Exception): pass
2197 2197
2198 2198 opts,args = self.parse_options(parameter_s,'prxn:')
2199 2199 # Set a few locals from the options for convenience:
2200 2200 opts_p = opts.has_key('p')
2201 2201 opts_r = opts.has_key('r')
2202 2202
2203 2203 # Default line number value
2204 2204 lineno = opts.get('n',None)
2205 2205
2206 2206 if opts_p:
2207 2207 args = '_%s' % last_call[0]
2208 2208 if not self.shell.user_ns.has_key(args):
2209 2209 args = last_call[1]
2210 2210
2211 2211 # use last_call to remember the state of the previous call, but don't
2212 2212 # let it be clobbered by successive '-p' calls.
2213 2213 try:
2214 2214 last_call[0] = self.shell.outputcache.prompt_count
2215 2215 if not opts_p:
2216 2216 last_call[1] = parameter_s
2217 2217 except:
2218 2218 pass
2219 2219
2220 2220 # by default this is done with temp files, except when the given
2221 2221 # arg is a filename
2222 2222 use_temp = 1
2223 2223
2224 2224 if re.match(r'\d',args):
2225 2225 # Mode where user specifies ranges of lines, like in %macro.
2226 2226 # This means that you can't edit files whose names begin with
2227 2227 # numbers this way. Tough.
2228 2228 ranges = args.split()
2229 2229 data = ''.join(self.extract_input_slices(ranges,opts_r))
2230 2230 elif args.endswith('.py'):
2231 2231 filename = make_filename(args)
2232 2232 data = ''
2233 2233 use_temp = 0
2234 2234 elif args:
2235 2235 try:
2236 2236 # Load the parameter given as a variable. If not a string,
2237 2237 # process it as an object instead (below)
2238 2238
2239 2239 #print '*** args',args,'type',type(args) # dbg
2240 2240 data = eval(args,self.shell.user_ns)
2241 2241 if not type(data) in StringTypes:
2242 2242 raise DataIsObject
2243 2243
2244 2244 except (NameError,SyntaxError):
2245 2245 # given argument is not a variable, try as a filename
2246 2246 filename = make_filename(args)
2247 2247 if filename is None:
2248 2248 warn("Argument given (%s) can't be found as a variable "
2249 2249 "or as a filename." % args)
2250 2250 return
2251 2251
2252 2252 data = ''
2253 2253 use_temp = 0
2254 2254 except DataIsObject:
2255 2255
2256 2256 # macros have a special edit function
2257 2257 if isinstance(data,Macro):
2258 2258 self._edit_macro(args,data)
2259 2259 return
2260 2260
2261 2261 # For objects, try to edit the file where they are defined
2262 2262 try:
2263 2263 filename = inspect.getabsfile(data)
2264 2264 if 'fakemodule' in filename.lower() and inspect.isclass(data):
2265 2265 # class created by %edit? Try to find source
2266 2266 # by looking for method definitions instead, the
2267 2267 # __module__ in those classes is FakeModule.
2268 2268 attrs = [getattr(data, aname) for aname in dir(data)]
2269 2269 for attr in attrs:
2270 2270 if not inspect.ismethod(attr):
2271 2271 continue
2272 2272 filename = inspect.getabsfile(attr)
2273 2273 if filename and 'fakemodule' not in filename.lower():
2274 2274 # change the attribute to be the edit target instead
2275 2275 data = attr
2276 2276 break
2277 2277
2278 2278 datafile = 1
2279 2279 except TypeError:
2280 2280 filename = make_filename(args)
2281 2281 datafile = 1
2282 2282 warn('Could not find file where `%s` is defined.\n'
2283 2283 'Opening a file named `%s`' % (args,filename))
2284 2284 # Now, make sure we can actually read the source (if it was in
2285 2285 # a temp file it's gone by now).
2286 2286 if datafile:
2287 2287 try:
2288 2288 if lineno is None:
2289 2289 lineno = inspect.getsourcelines(data)[1]
2290 2290 except IOError:
2291 2291 filename = make_filename(args)
2292 2292 if filename is None:
2293 2293 warn('The file `%s` where `%s` was defined cannot '
2294 2294 'be read.' % (filename,data))
2295 2295 return
2296 2296 use_temp = 0
2297 2297 else:
2298 2298 data = ''
2299 2299
2300 2300 if use_temp:
2301 2301 filename = self.shell.mktempfile(data)
2302 2302 print 'IPython will make a temporary file named:',filename
2303 2303
2304 2304 # do actual editing here
2305 2305 print 'Editing...',
2306 2306 sys.stdout.flush()
2307 2307 self.shell.hooks.editor(filename,lineno)
2308 2308 if opts.has_key('x'): # -x prevents actual execution
2309 2309 print
2310 2310 else:
2311 2311 print 'done. Executing edited code...'
2312 2312 if opts_r:
2313 2313 self.shell.runlines(file_read(filename))
2314 2314 else:
2315 2315 self.shell.safe_execfile(filename,self.shell.user_ns,
2316 2316 self.shell.user_ns)
2317 2317 if use_temp:
2318 2318 try:
2319 2319 return open(filename).read()
2320 2320 except IOError,msg:
2321 2321 if msg.filename == filename:
2322 2322 warn('File not found. Did you forget to save?')
2323 2323 return
2324 2324 else:
2325 2325 self.shell.showtraceback()
2326 2326
2327 2327 def magic_xmode(self,parameter_s = ''):
2328 2328 """Switch modes for the exception handlers.
2329 2329
2330 2330 Valid modes: Plain, Context and Verbose.
2331 2331
2332 2332 If called without arguments, acts as a toggle."""
2333 2333
2334 2334 def xmode_switch_err(name):
2335 2335 warn('Error changing %s exception modes.\n%s' %
2336 2336 (name,sys.exc_info()[1]))
2337 2337
2338 2338 shell = self.shell
2339 2339 new_mode = parameter_s.strip().capitalize()
2340 2340 try:
2341 2341 shell.InteractiveTB.set_mode(mode=new_mode)
2342 2342 print 'Exception reporting mode:',shell.InteractiveTB.mode
2343 2343 except:
2344 2344 xmode_switch_err('user')
2345 2345
2346 2346 # threaded shells use a special handler in sys.excepthook
2347 2347 if shell.isthreaded:
2348 2348 try:
2349 2349 shell.sys_excepthook.set_mode(mode=new_mode)
2350 2350 except:
2351 2351 xmode_switch_err('threaded')
2352 2352
2353 2353 def magic_colors(self,parameter_s = ''):
2354 2354 """Switch color scheme for prompts, info system and exception handlers.
2355 2355
2356 2356 Currently implemented schemes: NoColor, Linux, LightBG.
2357 2357
2358 2358 Color scheme names are not case-sensitive."""
2359 2359
2360 2360 def color_switch_err(name):
2361 2361 warn('Error changing %s color schemes.\n%s' %
2362 2362 (name,sys.exc_info()[1]))
2363 2363
2364 2364
2365 2365 new_scheme = parameter_s.strip()
2366 2366 if not new_scheme:
2367 2367 raise UsageError(
2368 2368 "%colors: you must specify a color scheme. See '%colors?'")
2369 2369 return
2370 2370 # local shortcut
2371 2371 shell = self.shell
2372 2372
2373 2373 import IPython.rlineimpl as readline
2374 2374
2375 2375 if not readline.have_readline and sys.platform == "win32":
2376 2376 msg = """\
2377 2377 Proper color support under MS Windows requires the pyreadline library.
2378 2378 You can find it at:
2379 2379 http://ipython.scipy.org/moin/PyReadline/Intro
2380 2380 Gary's readline needs the ctypes module, from:
2381 2381 http://starship.python.net/crew/theller/ctypes
2382 2382 (Note that ctypes is already part of Python versions 2.5 and newer).
2383 2383
2384 2384 Defaulting color scheme to 'NoColor'"""
2385 2385 new_scheme = 'NoColor'
2386 2386 warn(msg)
2387 2387
2388 2388 # readline option is 0
2389 2389 if not shell.has_readline:
2390 2390 new_scheme = 'NoColor'
2391 2391
2392 2392 # Set prompt colors
2393 2393 try:
2394 2394 shell.outputcache.set_colors(new_scheme)
2395 2395 except:
2396 2396 color_switch_err('prompt')
2397 2397 else:
2398 2398 shell.rc.colors = \
2399 2399 shell.outputcache.color_table.active_scheme_name
2400 2400 # Set exception colors
2401 2401 try:
2402 2402 shell.InteractiveTB.set_colors(scheme = new_scheme)
2403 2403 shell.SyntaxTB.set_colors(scheme = new_scheme)
2404 2404 except:
2405 2405 color_switch_err('exception')
2406 2406
2407 2407 # threaded shells use a verbose traceback in sys.excepthook
2408 2408 if shell.isthreaded:
2409 2409 try:
2410 2410 shell.sys_excepthook.set_colors(scheme=new_scheme)
2411 2411 except:
2412 2412 color_switch_err('system exception handler')
2413 2413
2414 2414 # Set info (for 'object?') colors
2415 2415 if shell.rc.color_info:
2416 2416 try:
2417 2417 shell.inspector.set_active_scheme(new_scheme)
2418 2418 except:
2419 2419 color_switch_err('object inspector')
2420 2420 else:
2421 2421 shell.inspector.set_active_scheme('NoColor')
2422 2422
2423 2423 def magic_color_info(self,parameter_s = ''):
2424 2424 """Toggle color_info.
2425 2425
2426 2426 The color_info configuration parameter controls whether colors are
2427 2427 used for displaying object details (by things like %psource, %pfile or
2428 2428 the '?' system). This function toggles this value with each call.
2429 2429
2430 2430 Note that unless you have a fairly recent pager (less works better
2431 2431 than more) in your system, using colored object information displays
2432 2432 will not work properly. Test it and see."""
2433 2433
2434 2434 self.shell.rc.color_info = 1 - self.shell.rc.color_info
2435 2435 self.magic_colors(self.shell.rc.colors)
2436 2436 print 'Object introspection functions have now coloring:',
2437 2437 print ['OFF','ON'][self.shell.rc.color_info]
2438 2438
2439 2439 def magic_Pprint(self, parameter_s=''):
2440 2440 """Toggle pretty printing on/off."""
2441 2441
2442 2442 self.shell.rc.pprint = 1 - self.shell.rc.pprint
2443 2443 print 'Pretty printing has been turned', \
2444 2444 ['OFF','ON'][self.shell.rc.pprint]
2445 2445
2446 2446 def magic_exit(self, parameter_s=''):
2447 2447 """Exit IPython, confirming if configured to do so.
2448 2448
2449 2449 You can configure whether IPython asks for confirmation upon exit by
2450 2450 setting the confirm_exit flag in the ipythonrc file."""
2451 2451
2452 2452 self.shell.exit()
2453 2453
2454 2454 def magic_quit(self, parameter_s=''):
2455 2455 """Exit IPython, confirming if configured to do so (like %exit)"""
2456 2456
2457 2457 self.shell.exit()
2458 2458
2459 2459 def magic_Exit(self, parameter_s=''):
2460 2460 """Exit IPython without confirmation."""
2461 2461
2462 2462 self.shell.exit_now = True
2463 2463
2464 2464 #......................................................................
2465 2465 # Functions to implement unix shell-type things
2466 2466
2467 2467 def magic_alias(self, parameter_s = ''):
2468 2468 """Define an alias for a system command.
2469 2469
2470 2470 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2471 2471
2472 2472 Then, typing 'alias_name params' will execute the system command 'cmd
2473 2473 params' (from your underlying operating system).
2474 2474
2475 2475 Aliases have lower precedence than magic functions and Python normal
2476 2476 variables, so if 'foo' is both a Python variable and an alias, the
2477 2477 alias can not be executed until 'del foo' removes the Python variable.
2478 2478
2479 2479 You can use the %l specifier in an alias definition to represent the
2480 2480 whole line when the alias is called. For example:
2481 2481
2482 2482 In [2]: alias all echo "Input in brackets: <%l>"\\
2483 2483 In [3]: all hello world\\
2484 2484 Input in brackets: <hello world>
2485 2485
2486 2486 You can also define aliases with parameters using %s specifiers (one
2487 2487 per parameter):
2488 2488
2489 2489 In [1]: alias parts echo first %s second %s\\
2490 2490 In [2]: %parts A B\\
2491 2491 first A second B\\
2492 2492 In [3]: %parts A\\
2493 2493 Incorrect number of arguments: 2 expected.\\
2494 2494 parts is an alias to: 'echo first %s second %s'
2495 2495
2496 2496 Note that %l and %s are mutually exclusive. You can only use one or
2497 2497 the other in your aliases.
2498 2498
2499 2499 Aliases expand Python variables just like system calls using ! or !!
2500 2500 do: all expressions prefixed with '$' get expanded. For details of
2501 2501 the semantic rules, see PEP-215:
2502 2502 http://www.python.org/peps/pep-0215.html. This is the library used by
2503 2503 IPython for variable expansion. If you want to access a true shell
2504 2504 variable, an extra $ is necessary to prevent its expansion by IPython:
2505 2505
2506 2506 In [6]: alias show echo\\
2507 2507 In [7]: PATH='A Python string'\\
2508 2508 In [8]: show $PATH\\
2509 2509 A Python string\\
2510 2510 In [9]: show $$PATH\\
2511 2511 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2512 2512
2513 2513 You can use the alias facility to acess all of $PATH. See the %rehash
2514 2514 and %rehashx functions, which automatically create aliases for the
2515 2515 contents of your $PATH.
2516 2516
2517 2517 If called with no parameters, %alias prints the current alias table."""
2518 2518
2519 2519 par = parameter_s.strip()
2520 2520 if not par:
2521 2521 stored = self.db.get('stored_aliases', {} )
2522 2522 atab = self.shell.alias_table
2523 2523 aliases = atab.keys()
2524 2524 aliases.sort()
2525 2525 res = []
2526 2526 showlast = []
2527 2527 for alias in aliases:
2528 2528 special = False
2529 2529 try:
2530 2530 tgt = atab[alias][1]
2531 2531 except (TypeError, AttributeError):
2532 2532 # unsubscriptable? probably a callable
2533 2533 tgt = atab[alias]
2534 2534 special = True
2535 2535 # 'interesting' aliases
2536 2536 if (alias in stored or
2537 2537 special or
2538 2538 alias.lower() != os.path.splitext(tgt)[0].lower() or
2539 2539 ' ' in tgt):
2540 2540 showlast.append((alias, tgt))
2541 2541 else:
2542 2542 res.append((alias, tgt ))
2543 2543
2544 2544 # show most interesting aliases last
2545 2545 res.extend(showlast)
2546 2546 print "Total number of aliases:",len(aliases)
2547 2547 return res
2548 2548 try:
2549 2549 alias,cmd = par.split(None,1)
2550 2550 except:
2551 2551 print OInspect.getdoc(self.magic_alias)
2552 2552 else:
2553 2553 nargs = cmd.count('%s')
2554 2554 if nargs>0 and cmd.find('%l')>=0:
2555 2555 error('The %s and %l specifiers are mutually exclusive '
2556 2556 'in alias definitions.')
2557 2557 else: # all looks OK
2558 2558 self.shell.alias_table[alias] = (nargs,cmd)
2559 2559 self.shell.alias_table_validate(verbose=0)
2560 2560 # end magic_alias
2561 2561
2562 2562 def magic_unalias(self, parameter_s = ''):
2563 2563 """Remove an alias"""
2564 2564
2565 2565 aname = parameter_s.strip()
2566 2566 if aname in self.shell.alias_table:
2567 2567 del self.shell.alias_table[aname]
2568 2568 stored = self.db.get('stored_aliases', {} )
2569 2569 if aname in stored:
2570 2570 print "Removing %stored alias",aname
2571 2571 del stored[aname]
2572 2572 self.db['stored_aliases'] = stored
2573 2573
2574 2574
2575 2575 def magic_rehashx(self, parameter_s = ''):
2576 2576 """Update the alias table with all executable files in $PATH.
2577 2577
2578 2578 This version explicitly checks that every entry in $PATH is a file
2579 2579 with execute access (os.X_OK), so it is much slower than %rehash.
2580 2580
2581 2581 Under Windows, it checks executability as a match agains a
2582 2582 '|'-separated string of extensions, stored in the IPython config
2583 2583 variable win_exec_ext. This defaults to 'exe|com|bat'.
2584 2584
2585 2585 This function also resets the root module cache of module completer,
2586 2586 used on slow filesystems.
2587 2587 """
2588 2588
2589 2589
2590 2590 ip = self.api
2591 2591
2592 2592 # for the benefit of module completer in ipy_completers.py
2593 2593 del ip.db['rootmodules']
2594 2594
2595 2595 path = [os.path.abspath(os.path.expanduser(p)) for p in
2596 2596 os.environ.get('PATH','').split(os.pathsep)]
2597 2597 path = filter(os.path.isdir,path)
2598 2598
2599 2599 alias_table = self.shell.alias_table
2600 2600 syscmdlist = []
2601 2601 if os.name == 'posix':
2602 2602 isexec = lambda fname:os.path.isfile(fname) and \
2603 2603 os.access(fname,os.X_OK)
2604 2604 else:
2605 2605
2606 2606 try:
2607 2607 winext = os.environ['pathext'].replace(';','|').replace('.','')
2608 2608 except KeyError:
2609 2609 winext = 'exe|com|bat|py'
2610 2610 if 'py' not in winext:
2611 2611 winext += '|py'
2612 2612 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2613 2613 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2614 2614 savedir = os.getcwd()
2615 2615 try:
2616 2616 # write the whole loop for posix/Windows so we don't have an if in
2617 2617 # the innermost part
2618 2618 if os.name == 'posix':
2619 2619 for pdir in path:
2620 2620 os.chdir(pdir)
2621 2621 for ff in os.listdir(pdir):
2622 2622 if isexec(ff) and ff not in self.shell.no_alias:
2623 2623 # each entry in the alias table must be (N,name),
2624 2624 # where N is the number of positional arguments of the
2625 2625 # alias.
2626 2626 alias_table[ff] = (0,ff)
2627 2627 syscmdlist.append(ff)
2628 2628 else:
2629 2629 for pdir in path:
2630 2630 os.chdir(pdir)
2631 2631 for ff in os.listdir(pdir):
2632 2632 base, ext = os.path.splitext(ff)
2633 2633 if isexec(ff) and base.lower() not in self.shell.no_alias:
2634 2634 if ext.lower() == '.exe':
2635 2635 ff = base
2636 2636 alias_table[base.lower()] = (0,ff)
2637 2637 syscmdlist.append(ff)
2638 2638 # Make sure the alias table doesn't contain keywords or builtins
2639 2639 self.shell.alias_table_validate()
2640 2640 # Call again init_auto_alias() so we get 'rm -i' and other
2641 2641 # modified aliases since %rehashx will probably clobber them
2642 2642
2643 2643 # no, we don't want them. if %rehashx clobbers them, good,
2644 2644 # we'll probably get better versions
2645 2645 # self.shell.init_auto_alias()
2646 2646 db = ip.db
2647 2647 db['syscmdlist'] = syscmdlist
2648 2648 finally:
2649 2649 os.chdir(savedir)
2650 2650
2651 2651 def magic_pwd(self, parameter_s = ''):
2652 2652 """Return the current working directory path."""
2653 2653 return os.getcwd()
2654 2654
2655 2655 def magic_cd(self, parameter_s=''):
2656 2656 """Change the current working directory.
2657 2657
2658 2658 This command automatically maintains an internal list of directories
2659 2659 you visit during your IPython session, in the variable _dh. The
2660 2660 command %dhist shows this history nicely formatted. You can also
2661 2661 do 'cd -<tab>' to see directory history conveniently.
2662 2662
2663 2663 Usage:
2664 2664
2665 2665 cd 'dir': changes to directory 'dir'.
2666 2666
2667 2667 cd -: changes to the last visited directory.
2668 2668
2669 2669 cd -<n>: changes to the n-th directory in the directory history.
2670 2670
2671 2671 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2672 2672 (note: cd <bookmark_name> is enough if there is no
2673 2673 directory <bookmark_name>, but a bookmark with the name exists.)
2674 2674 'cd -b <tab>' allows you to tab-complete bookmark names.
2675 2675
2676 2676 Options:
2677 2677
2678 2678 -q: quiet. Do not print the working directory after the cd command is
2679 2679 executed. By default IPython's cd command does print this directory,
2680 2680 since the default prompts do not display path information.
2681 2681
2682 2682 Note that !cd doesn't work for this purpose because the shell where
2683 2683 !command runs is immediately discarded after executing 'command'."""
2684 2684
2685 2685 parameter_s = parameter_s.strip()
2686 2686 #bkms = self.shell.persist.get("bookmarks",{})
2687 2687
2688 2688 oldcwd = os.getcwd()
2689 2689 numcd = re.match(r'(-)(\d+)$',parameter_s)
2690 2690 # jump in directory history by number
2691 2691 if numcd:
2692 2692 nn = int(numcd.group(2))
2693 2693 try:
2694 2694 ps = self.shell.user_ns['_dh'][nn]
2695 2695 except IndexError:
2696 2696 print 'The requested directory does not exist in history.'
2697 2697 return
2698 2698 else:
2699 2699 opts = {}
2700 2700 else:
2701 2701 #turn all non-space-escaping backslashes to slashes,
2702 2702 # for c:\windows\directory\names\
2703 2703 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2704 2704 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2705 2705 # jump to previous
2706 2706 if ps == '-':
2707 2707 try:
2708 2708 ps = self.shell.user_ns['_dh'][-2]
2709 2709 except IndexError:
2710 2710 raise UsageError('%cd -: No previous directory to change to.')
2711 2711 # jump to bookmark if needed
2712 2712 else:
2713 2713 if not os.path.isdir(ps) or opts.has_key('b'):
2714 2714 bkms = self.db.get('bookmarks', {})
2715 2715
2716 2716 if bkms.has_key(ps):
2717 2717 target = bkms[ps]
2718 2718 print '(bookmark:%s) -> %s' % (ps,target)
2719 2719 ps = target
2720 2720 else:
2721 2721 if opts.has_key('b'):
2722 2722 raise UsageError("Bookmark '%s' not found. "
2723 2723 "Use '%%bookmark -l' to see your bookmarks." % ps)
2724 2724
2725 2725 # at this point ps should point to the target dir
2726 2726 if ps:
2727 2727 try:
2728 2728 os.chdir(os.path.expanduser(ps))
2729 2729 if self.shell.rc.term_title:
2730 2730 #print 'set term title:',self.shell.rc.term_title # dbg
2731 2731 ttitle = 'IPy ' + abbrev_cwd()
2732 2732 platutils.set_term_title(ttitle)
2733 2733 except OSError:
2734 2734 print sys.exc_info()[1]
2735 2735 else:
2736 2736 cwd = os.getcwd()
2737 2737 dhist = self.shell.user_ns['_dh']
2738 2738 if oldcwd != cwd:
2739 2739 dhist.append(cwd)
2740 2740 self.db['dhist'] = compress_dhist(dhist)[-100:]
2741 2741
2742 2742 else:
2743 2743 os.chdir(self.shell.home_dir)
2744 2744 if self.shell.rc.term_title:
2745 2745 platutils.set_term_title("IPy ~")
2746 2746 cwd = os.getcwd()
2747 2747 dhist = self.shell.user_ns['_dh']
2748 2748
2749 2749 if oldcwd != cwd:
2750 2750 dhist.append(cwd)
2751 2751 self.db['dhist'] = compress_dhist(dhist)[-100:]
2752 2752 if not 'q' in opts and self.shell.user_ns['_dh']:
2753 2753 print self.shell.user_ns['_dh'][-1]
2754 2754
2755 2755
2756 2756 def magic_env(self, parameter_s=''):
2757 2757 """List environment variables."""
2758 2758
2759 2759 return os.environ.data
2760 2760
2761 2761 def magic_pushd(self, parameter_s=''):
2762 2762 """Place the current dir on stack and change directory.
2763 2763
2764 2764 Usage:\\
2765 2765 %pushd ['dirname']
2766 2766 """
2767 2767
2768 2768 dir_s = self.shell.dir_stack
2769 2769 tgt = os.path.expanduser(parameter_s)
2770 2770 cwd = os.getcwd().replace(self.home_dir,'~')
2771 2771 if tgt:
2772 2772 self.magic_cd(parameter_s)
2773 2773 dir_s.insert(0,cwd)
2774 2774 return self.magic_dirs()
2775 2775
2776 2776 def magic_popd(self, parameter_s=''):
2777 2777 """Change to directory popped off the top of the stack.
2778 2778 """
2779 2779 if not self.shell.dir_stack:
2780 2780 raise UsageError("%popd on empty stack")
2781 2781 top = self.shell.dir_stack.pop(0)
2782 2782 self.magic_cd(top)
2783 2783 print "popd ->",top
2784 2784
2785 2785 def magic_dirs(self, parameter_s=''):
2786 2786 """Return the current directory stack."""
2787 2787
2788 2788 return self.shell.dir_stack
2789 2789
2790 2790 def magic_dhist(self, parameter_s=''):
2791 2791 """Print your history of visited directories.
2792 2792
2793 2793 %dhist -> print full history\\
2794 2794 %dhist n -> print last n entries only\\
2795 2795 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2796 2796
2797 2797 This history is automatically maintained by the %cd command, and
2798 2798 always available as the global list variable _dh. You can use %cd -<n>
2799 2799 to go to directory number <n>.
2800 2800
2801 2801 Note that most of time, you should view directory history by entering
2802 2802 cd -<TAB>.
2803 2803
2804 2804 """
2805 2805
2806 2806 dh = self.shell.user_ns['_dh']
2807 2807 if parameter_s:
2808 2808 try:
2809 2809 args = map(int,parameter_s.split())
2810 2810 except:
2811 2811 self.arg_err(Magic.magic_dhist)
2812 2812 return
2813 2813 if len(args) == 1:
2814 2814 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2815 2815 elif len(args) == 2:
2816 2816 ini,fin = args
2817 2817 else:
2818 2818 self.arg_err(Magic.magic_dhist)
2819 2819 return
2820 2820 else:
2821 2821 ini,fin = 0,len(dh)
2822 2822 nlprint(dh,
2823 2823 header = 'Directory history (kept in _dh)',
2824 2824 start=ini,stop=fin)
2825 2825
2826 2826
2827 2827 def magic_sc(self, parameter_s=''):
2828 2828 """Shell capture - execute a shell command and capture its output.
2829 2829
2830 2830 DEPRECATED. Suboptimal, retained for backwards compatibility.
2831 2831
2832 2832 You should use the form 'var = !command' instead. Example:
2833 2833
2834 2834 "%sc -l myfiles = ls ~" should now be written as
2835 2835
2836 2836 "myfiles = !ls ~"
2837 2837
2838 2838 myfiles.s, myfiles.l and myfiles.n still apply as documented
2839 2839 below.
2840 2840
2841 2841 --
2842 2842 %sc [options] varname=command
2843 2843
2844 2844 IPython will run the given command using commands.getoutput(), and
2845 2845 will then update the user's interactive namespace with a variable
2846 2846 called varname, containing the value of the call. Your command can
2847 2847 contain shell wildcards, pipes, etc.
2848 2848
2849 2849 The '=' sign in the syntax is mandatory, and the variable name you
2850 2850 supply must follow Python's standard conventions for valid names.
2851 2851
2852 2852 (A special format without variable name exists for internal use)
2853 2853
2854 2854 Options:
2855 2855
2856 2856 -l: list output. Split the output on newlines into a list before
2857 2857 assigning it to the given variable. By default the output is stored
2858 2858 as a single string.
2859 2859
2860 2860 -v: verbose. Print the contents of the variable.
2861 2861
2862 2862 In most cases you should not need to split as a list, because the
2863 2863 returned value is a special type of string which can automatically
2864 2864 provide its contents either as a list (split on newlines) or as a
2865 2865 space-separated string. These are convenient, respectively, either
2866 2866 for sequential processing or to be passed to a shell command.
2867 2867
2868 2868 For example:
2869 2869
2870 2870 # Capture into variable a
2871 2871 In [9]: sc a=ls *py
2872 2872
2873 2873 # a is a string with embedded newlines
2874 2874 In [10]: a
2875 2875 Out[10]: 'setup.py\nwin32_manual_post_install.py'
2876 2876
2877 2877 # which can be seen as a list:
2878 2878 In [11]: a.l
2879 2879 Out[11]: ['setup.py', 'win32_manual_post_install.py']
2880 2880
2881 2881 # or as a whitespace-separated string:
2882 2882 In [12]: a.s
2883 2883 Out[12]: 'setup.py win32_manual_post_install.py'
2884 2884
2885 2885 # a.s is useful to pass as a single command line:
2886 2886 In [13]: !wc -l $a.s
2887 2887 146 setup.py
2888 2888 130 win32_manual_post_install.py
2889 2889 276 total
2890 2890
2891 2891 # while the list form is useful to loop over:
2892 2892 In [14]: for f in a.l:
2893 2893 ....: !wc -l $f
2894 2894 ....:
2895 2895 146 setup.py
2896 2896 130 win32_manual_post_install.py
2897 2897
2898 2898 Similiarly, the lists returned by the -l option are also special, in
2899 2899 the sense that you can equally invoke the .s attribute on them to
2900 2900 automatically get a whitespace-separated string from their contents:
2901 2901
2902 2902 In [1]: sc -l b=ls *py
2903 2903
2904 2904 In [2]: b
2905 2905 Out[2]: ['setup.py', 'win32_manual_post_install.py']
2906 2906
2907 2907 In [3]: b.s
2908 2908 Out[3]: 'setup.py win32_manual_post_install.py'
2909 2909
2910 2910 In summary, both the lists and strings used for ouptut capture have
2911 2911 the following special attributes:
2912 2912
2913 2913 .l (or .list) : value as list.
2914 2914 .n (or .nlstr): value as newline-separated string.
2915 2915 .s (or .spstr): value as space-separated string.
2916 2916 """
2917 2917
2918 2918 opts,args = self.parse_options(parameter_s,'lv')
2919 2919 # Try to get a variable name and command to run
2920 2920 try:
2921 2921 # the variable name must be obtained from the parse_options
2922 2922 # output, which uses shlex.split to strip options out.
2923 2923 var,_ = args.split('=',1)
2924 2924 var = var.strip()
2925 2925 # But the the command has to be extracted from the original input
2926 2926 # parameter_s, not on what parse_options returns, to avoid the
2927 2927 # quote stripping which shlex.split performs on it.
2928 2928 _,cmd = parameter_s.split('=',1)
2929 2929 except ValueError:
2930 2930 var,cmd = '',''
2931 2931 # If all looks ok, proceed
2932 2932 out,err = self.shell.getoutputerror(cmd)
2933 2933 if err:
2934 2934 print >> Term.cerr,err
2935 2935 if opts.has_key('l'):
2936 2936 out = SList(out.split('\n'))
2937 2937 else:
2938 2938 out = LSString(out)
2939 2939 if opts.has_key('v'):
2940 2940 print '%s ==\n%s' % (var,pformat(out))
2941 2941 if var:
2942 2942 self.shell.user_ns.update({var:out})
2943 2943 else:
2944 2944 return out
2945 2945
2946 2946 def magic_sx(self, parameter_s=''):
2947 2947 """Shell execute - run a shell command and capture its output.
2948 2948
2949 2949 %sx command
2950 2950
2951 2951 IPython will run the given command using commands.getoutput(), and
2952 2952 return the result formatted as a list (split on '\\n'). Since the
2953 2953 output is _returned_, it will be stored in ipython's regular output
2954 2954 cache Out[N] and in the '_N' automatic variables.
2955 2955
2956 2956 Notes:
2957 2957
2958 2958 1) If an input line begins with '!!', then %sx is automatically
2959 2959 invoked. That is, while:
2960 2960 !ls
2961 2961 causes ipython to simply issue system('ls'), typing
2962 2962 !!ls
2963 2963 is a shorthand equivalent to:
2964 2964 %sx ls
2965 2965
2966 2966 2) %sx differs from %sc in that %sx automatically splits into a list,
2967 2967 like '%sc -l'. The reason for this is to make it as easy as possible
2968 2968 to process line-oriented shell output via further python commands.
2969 2969 %sc is meant to provide much finer control, but requires more
2970 2970 typing.
2971 2971
2972 2972 3) Just like %sc -l, this is a list with special attributes:
2973 2973
2974 2974 .l (or .list) : value as list.
2975 2975 .n (or .nlstr): value as newline-separated string.
2976 2976 .s (or .spstr): value as whitespace-separated string.
2977 2977
2978 2978 This is very useful when trying to use such lists as arguments to
2979 2979 system commands."""
2980 2980
2981 2981 if parameter_s:
2982 2982 out,err = self.shell.getoutputerror(parameter_s)
2983 2983 if err:
2984 2984 print >> Term.cerr,err
2985 2985 return SList(out.split('\n'))
2986 2986
2987 2987 def magic_bg(self, parameter_s=''):
2988 2988 """Run a job in the background, in a separate thread.
2989 2989
2990 2990 For example,
2991 2991
2992 2992 %bg myfunc(x,y,z=1)
2993 2993
2994 2994 will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
2995 2995 execution starts, a message will be printed indicating the job
2996 2996 number. If your job number is 5, you can use
2997 2997
2998 2998 myvar = jobs.result(5) or myvar = jobs[5].result
2999 2999
3000 3000 to assign this result to variable 'myvar'.
3001 3001
3002 3002 IPython has a job manager, accessible via the 'jobs' object. You can
3003 3003 type jobs? to get more information about it, and use jobs.<TAB> to see
3004 3004 its attributes. All attributes not starting with an underscore are
3005 3005 meant for public use.
3006 3006
3007 3007 In particular, look at the jobs.new() method, which is used to create
3008 3008 new jobs. This magic %bg function is just a convenience wrapper
3009 3009 around jobs.new(), for expression-based jobs. If you want to create a
3010 3010 new job with an explicit function object and arguments, you must call
3011 3011 jobs.new() directly.
3012 3012
3013 3013 The jobs.new docstring also describes in detail several important
3014 3014 caveats associated with a thread-based model for background job
3015 3015 execution. Type jobs.new? for details.
3016 3016
3017 3017 You can check the status of all jobs with jobs.status().
3018 3018
3019 3019 The jobs variable is set by IPython into the Python builtin namespace.
3020 3020 If you ever declare a variable named 'jobs', you will shadow this
3021 3021 name. You can either delete your global jobs variable to regain
3022 3022 access to the job manager, or make a new name and assign it manually
3023 3023 to the manager (stored in IPython's namespace). For example, to
3024 3024 assign the job manager to the Jobs name, use:
3025 3025
3026 3026 Jobs = __builtins__.jobs"""
3027 3027
3028 3028 self.shell.jobs.new(parameter_s,self.shell.user_ns)
3029 3029
3030 3030 def magic_r(self, parameter_s=''):
3031 3031 """Repeat previous input.
3032 3032
3033 3033 Note: Consider using the more powerfull %rep instead!
3034 3034
3035 3035 If given an argument, repeats the previous command which starts with
3036 3036 the same string, otherwise it just repeats the previous input.
3037 3037
3038 3038 Shell escaped commands (with ! as first character) are not recognized
3039 3039 by this system, only pure python code and magic commands.
3040 3040 """
3041 3041
3042 3042 start = parameter_s.strip()
3043 3043 esc_magic = self.shell.ESC_MAGIC
3044 3044 # Identify magic commands even if automagic is on (which means
3045 3045 # the in-memory version is different from that typed by the user).
3046 3046 if self.shell.rc.automagic:
3047 3047 start_magic = esc_magic+start
3048 3048 else:
3049 3049 start_magic = start
3050 3050 # Look through the input history in reverse
3051 3051 for n in range(len(self.shell.input_hist)-2,0,-1):
3052 3052 input = self.shell.input_hist[n]
3053 3053 # skip plain 'r' lines so we don't recurse to infinity
3054 3054 if input != '_ip.magic("r")\n' and \
3055 3055 (input.startswith(start) or input.startswith(start_magic)):
3056 3056 #print 'match',`input` # dbg
3057 3057 print 'Executing:',input,
3058 3058 self.shell.runlines(input)
3059 3059 return
3060 3060 print 'No previous input matching `%s` found.' % start
3061 3061
3062 3062
3063 3063 def magic_bookmark(self, parameter_s=''):
3064 3064 """Manage IPython's bookmark system.
3065 3065
3066 3066 %bookmark <name> - set bookmark to current dir
3067 3067 %bookmark <name> <dir> - set bookmark to <dir>
3068 3068 %bookmark -l - list all bookmarks
3069 3069 %bookmark -d <name> - remove bookmark
3070 3070 %bookmark -r - remove all bookmarks
3071 3071
3072 3072 You can later on access a bookmarked folder with:
3073 3073 %cd -b <name>
3074 3074 or simply '%cd <name>' if there is no directory called <name> AND
3075 3075 there is such a bookmark defined.
3076 3076
3077 3077 Your bookmarks persist through IPython sessions, but they are
3078 3078 associated with each profile."""
3079 3079
3080 3080 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3081 3081 if len(args) > 2:
3082 3082 raise UsageError("%bookmark: too many arguments")
3083 3083
3084 3084 bkms = self.db.get('bookmarks',{})
3085 3085
3086 3086 if opts.has_key('d'):
3087 3087 try:
3088 3088 todel = args[0]
3089 3089 except IndexError:
3090 3090 raise UsageError(
3091 3091 "%bookmark -d: must provide a bookmark to delete")
3092 3092 else:
3093 3093 try:
3094 3094 del bkms[todel]
3095 3095 except KeyError:
3096 3096 raise UsageError(
3097 3097 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3098 3098
3099 3099 elif opts.has_key('r'):
3100 3100 bkms = {}
3101 3101 elif opts.has_key('l'):
3102 3102 bks = bkms.keys()
3103 3103 bks.sort()
3104 3104 if bks:
3105 3105 size = max(map(len,bks))
3106 3106 else:
3107 3107 size = 0
3108 3108 fmt = '%-'+str(size)+'s -> %s'
3109 3109 print 'Current bookmarks:'
3110 3110 for bk in bks:
3111 3111 print fmt % (bk,bkms[bk])
3112 3112 else:
3113 3113 if not args:
3114 3114 raise UsageError("%bookmark: You must specify the bookmark name")
3115 3115 elif len(args)==1:
3116 3116 bkms[args[0]] = os.getcwd()
3117 3117 elif len(args)==2:
3118 3118 bkms[args[0]] = args[1]
3119 3119 self.db['bookmarks'] = bkms
3120 3120
3121 3121 def magic_pycat(self, parameter_s=''):
3122 3122 """Show a syntax-highlighted file through a pager.
3123 3123
3124 3124 This magic is similar to the cat utility, but it will assume the file
3125 3125 to be Python source and will show it with syntax highlighting. """
3126 3126
3127 3127 try:
3128 3128 filename = get_py_filename(parameter_s)
3129 3129 cont = file_read(filename)
3130 3130 except IOError:
3131 3131 try:
3132 3132 cont = eval(parameter_s,self.user_ns)
3133 3133 except NameError:
3134 3134 cont = None
3135 3135 if cont is None:
3136 3136 print "Error: no such file or variable"
3137 3137 return
3138 3138
3139 3139 page(self.shell.pycolorize(cont),
3140 3140 screen_lines=self.shell.rc.screen_length)
3141 3141
3142 3142 def magic_cpaste(self, parameter_s=''):
3143 3143 """Allows you to paste & execute a pre-formatted code block from clipboard
3144 3144
3145 3145 You must terminate the block with '--' (two minus-signs) alone on the
3146 3146 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
3147 3147 is the new sentinel for this operation)
3148 3148
3149 3149 The block is dedented prior to execution to enable execution of method
3150 3150 definitions. '>' and '+' characters at the beginning of a line are
3151 ignored, to allow pasting directly from e-mails or diff files. The
3152 executed block is also assigned to variable named 'pasted_block' for
3151 ignored, to allow pasting directly from e-mails, diff files and doctests.
3152 The executed block is also assigned to variable named 'pasted_block' for
3153 3153 later editing with '%edit pasted_block'.
3154 3154
3155 3155 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
3156 3156 This assigns the pasted block to variable 'foo' as string, without
3157 dedenting or executing it.
3157 dedenting or executing it (preceding >>> and + is still stripped)
3158 3158
3159 3159 Do not be alarmed by garbled output on Windows (it's a readline bug).
3160 3160 Just press enter and type -- (and press enter again) and the block
3161 3161 will be what was just pasted.
3162 3162
3163 3163 IPython statements (magics, shell escapes) are not supported (yet).
3164 3164 """
3165 3165 opts,args = self.parse_options(parameter_s,'s:',mode='string')
3166 3166 par = args.strip()
3167 3167 sentinel = opts.get('s','--')
3168 3168
3169 3169 strip_from_start = [re.compile(e) for e in
3170 ['^(.?>)+','^In \[\d+\]:','^\++']]
3170 [r'^\s*(\s?>)+',r'^\s*In \[\d+\]:',r'^\++']]
3171 3171 from IPython import iplib
3172 3172 lines = []
3173 3173 print "Pasting code; enter '%s' alone on the line to stop." % sentinel
3174 3174 while 1:
3175 3175 l = iplib.raw_input_original(':')
3176 3176 if l ==sentinel:
3177 3177 break
3178 3178
3179 3179 for pat in strip_from_start:
3180 3180 l = pat.sub('',l)
3181 3181 lines.append(l)
3182 3182
3183 3183 block = "\n".join(lines) + '\n'
3184 3184 #print "block:\n",block
3185 3185 if not par:
3186 3186 b = textwrap.dedent(block)
3187 3187 exec b in self.user_ns
3188 3188 self.user_ns['pasted_block'] = b
3189 3189 else:
3190 3190 self.user_ns[par] = block
3191 3191 print "Block assigned to '%s'" % par
3192 3192
3193 3193 def magic_quickref(self,arg):
3194 3194 """ Show a quick reference sheet """
3195 3195 import IPython.usage
3196 3196 qr = IPython.usage.quick_reference + self.magic_magic('-brief')
3197 3197
3198 3198 page(qr)
3199 3199
3200 3200 def magic_upgrade(self,arg):
3201 3201 """ Upgrade your IPython installation
3202 3202
3203 3203 This will copy the config files that don't yet exist in your
3204 3204 ipython dir from the system config dir. Use this after upgrading
3205 3205 IPython if you don't wish to delete your .ipython dir.
3206 3206
3207 3207 Call with -nolegacy to get rid of ipythonrc* files (recommended for
3208 3208 new users)
3209 3209
3210 3210 """
3211 3211 ip = self.getapi()
3212 3212 ipinstallation = path(IPython.__file__).dirname()
3213 3213 upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'upgrade_dir.py')
3214 3214 src_config = ipinstallation / 'UserConfig'
3215 3215 userdir = path(ip.options.ipythondir)
3216 3216 cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
3217 3217 print ">",cmd
3218 3218 shell(cmd)
3219 3219 if arg == '-nolegacy':
3220 3220 legacy = userdir.files('ipythonrc*')
3221 3221 print "Nuking legacy files:",legacy
3222 3222
3223 3223 [p.remove() for p in legacy]
3224 3224 suffix = (sys.platform == 'win32' and '.ini' or '')
3225 3225 (userdir / ('ipythonrc' + suffix)).write_text('# Empty, see ipy_user_conf.py\n')
3226 3226
3227 3227
3228 3228 def magic_doctest_mode(self,parameter_s=''):
3229 3229 """Toggle doctest mode on and off.
3230 3230
3231 3231 This mode allows you to toggle the prompt behavior between normal
3232 3232 IPython prompts and ones that are as similar to the default IPython
3233 3233 interpreter as possible.
3234 3234
3235 3235 It also supports the pasting of code snippets that have leading '>>>'
3236 3236 and '...' prompts in them. This means that you can paste doctests from
3237 3237 files or docstrings (even if they have leading whitespace), and the
3238 3238 code will execute correctly. You can then use '%history -tn' to see
3239 3239 the translated history without line numbers; this will give you the
3240 3240 input after removal of all the leading prompts and whitespace, which
3241 3241 can be pasted back into an editor.
3242 3242
3243 3243 With these features, you can switch into this mode easily whenever you
3244 3244 need to do testing and changes to doctests, without having to leave
3245 3245 your existing IPython session.
3246 3246 """
3247 3247
3248 3248 # XXX - Fix this to have cleaner activate/deactivate calls.
3249 3249 from IPython.Extensions import InterpreterPasteInput as ipaste
3250 3250 from IPython.ipstruct import Struct
3251 3251
3252 3252 # Shorthands
3253 3253 shell = self.shell
3254 3254 oc = shell.outputcache
3255 3255 rc = shell.rc
3256 3256 meta = shell.meta
3257 3257 # dstore is a data store kept in the instance metadata bag to track any
3258 3258 # changes we make, so we can undo them later.
3259 3259 dstore = meta.setdefault('doctest_mode',Struct())
3260 3260 save_dstore = dstore.setdefault
3261 3261
3262 3262 # save a few values we'll need to recover later
3263 3263 mode = save_dstore('mode',False)
3264 3264 save_dstore('rc_pprint',rc.pprint)
3265 3265 save_dstore('xmode',shell.InteractiveTB.mode)
3266 3266 save_dstore('rc_separate_out',rc.separate_out)
3267 3267 save_dstore('rc_separate_out2',rc.separate_out2)
3268 3268 save_dstore('rc_prompts_pad_left',rc.prompts_pad_left)
3269 3269
3270 3270 if mode == False:
3271 3271 # turn on
3272 3272 ipaste.activate_prefilter()
3273 3273
3274 3274 oc.prompt1.p_template = '>>> '
3275 3275 oc.prompt2.p_template = '... '
3276 3276 oc.prompt_out.p_template = ''
3277 3277
3278 3278 oc.output_sep = ''
3279 3279 oc.output_sep2 = ''
3280 3280
3281 3281 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3282 3282 oc.prompt_out.pad_left = False
3283 3283
3284 3284 rc.pprint = False
3285 3285
3286 3286 shell.magic_xmode('Plain')
3287 3287
3288 3288 else:
3289 3289 # turn off
3290 3290 ipaste.deactivate_prefilter()
3291 3291
3292 3292 oc.prompt1.p_template = rc.prompt_in1
3293 3293 oc.prompt2.p_template = rc.prompt_in2
3294 3294 oc.prompt_out.p_template = rc.prompt_out
3295 3295
3296 3296 oc.output_sep = dstore.rc_separate_out
3297 3297 oc.output_sep2 = dstore.rc_separate_out2
3298 3298
3299 3299 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3300 3300 oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
3301 3301
3302 3302 rc.pprint = dstore.rc_pprint
3303 3303
3304 3304 shell.magic_xmode(dstore.xmode)
3305 3305
3306 3306 # Store new mode and inform
3307 3307 dstore.mode = bool(1-int(mode))
3308 3308 print 'Doctest mode is:',
3309 3309 print ['OFF','ON'][dstore.mode]
3310 3310
3311 3311 # end Magic
@@ -1,87 +1,89 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Release data for the IPython project.
3 3
4 4 $Id: Release.py 3002 2008-02-01 07:17:00Z fperez $"""
5 5
6 6 #*****************************************************************************
7 7 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
8 8 #
9 9 # Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
10 10 # <n8gray@caltech.edu>
11 11 #
12 12 # Distributed under the terms of the BSD License. The full license is in
13 13 # the file COPYING, distributed as part of this software.
14 14 #*****************************************************************************
15 15
16 16 # Name of the package for release purposes. This is the name which labels
17 17 # the tarballs and RPMs made by distutils, so it's best to lowercase it.
18 18 name = 'ipython'
19 19
20 20 # For versions with substrings (like 0.6.16.svn), use an extra . to separate
21 21 # the new substring. We have to avoid using either dashes or underscores,
22 22 # because bdist_rpm does not accept dashes (an RPM) convention, and
23 23 # bdist_deb does not accept underscores (a Debian convention).
24 24
25 revision = '109'
25 revision = '117'
26 26 branch = 'ipython'
27 27
28 28 if branch == 'ipython':
29 29 version = '0.8.3.bzr.r' + revision
30 30 else:
31 31 version = '0.8.3.bzr.r%s.%s' % (revision,branch)
32 32
33 version = '0.8.3'
34
33 35 description = "An enhanced interactive Python shell."
34 36
35 37 long_description = \
36 38 """
37 39 IPython provides a replacement for the interactive Python interpreter with
38 40 extra functionality.
39 41
40 42 Main features:
41 43
42 44 * Comprehensive object introspection.
43 45
44 46 * Input history, persistent across sessions.
45 47
46 48 * Caching of output results during a session with automatically generated
47 49 references.
48 50
49 51 * Readline based name completion.
50 52
51 53 * Extensible system of 'magic' commands for controlling the environment and
52 54 performing many tasks related either to IPython or the operating system.
53 55
54 56 * Configuration system with easy switching between different setups (simpler
55 57 than changing $PYTHONSTARTUP environment variables every time).
56 58
57 59 * Session logging and reloading.
58 60
59 61 * Extensible syntax processing for special purpose situations.
60 62
61 63 * Access to the system shell with user-extensible alias system.
62 64
63 65 * Easily embeddable in other Python programs.
64 66
65 67 * Integrated access to the pdb debugger and the Python profiler.
66 68
67 69 The latest development version is always available at the IPython subversion
68 70 repository_.
69 71
70 72 .. _repository: http://ipython.scipy.org/svn/ipython/ipython/trunk#egg=ipython-dev
71 73 """
72 74
73 75 license = 'BSD'
74 76
75 77 authors = {'Fernando' : ('Fernando Perez','fperez@colorado.edu'),
76 78 'Janko' : ('Janko Hauser','jhauser@zscout.de'),
77 79 'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu'),
78 80 'Ville' : ('Ville Vainio','vivainio@gmail.com')
79 81 }
80 82
81 83 url = 'http://ipython.scipy.org'
82 84
83 85 download_url = 'http://ipython.scipy.org/dist'
84 86
85 87 platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
86 88
87 89 keywords = ['Interactive','Interpreter','Shell']
@@ -1,2040 +1,2043 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 General purpose utilities.
4 4
5 5 This is a grab-bag of stuff I find useful in most programs I write. Some of
6 6 these things are also convenient when working at the command line.
7 7
8 8 $Id: genutils.py 2998 2008-01-31 10:06:04Z vivainio $"""
9 9
10 10 #*****************************************************************************
11 11 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
12 12 #
13 13 # Distributed under the terms of the BSD License. The full license is in
14 14 # the file COPYING, distributed as part of this software.
15 15 #*****************************************************************************
16 16
17 17 from IPython import Release
18 18 __author__ = '%s <%s>' % Release.authors['Fernando']
19 19 __license__ = Release.license
20 20
21 21 #****************************************************************************
22 22 # required modules from the Python standard library
23 23 import __main__
24 24 import commands
25 import doctest
25 try:
26 import doctest
27 except ImportError:
28 pass
26 29 import os
27 30 import re
28 31 import shlex
29 32 import shutil
30 33 import sys
31 34 import tempfile
32 35 import time
33 36 import types
34 37 import warnings
35 38
36 39 # Curses and termios are Unix-only modules
37 40 try:
38 41 import curses
39 42 # We need termios as well, so if its import happens to raise, we bail on
40 43 # using curses altogether.
41 44 import termios
42 45 except ImportError:
43 46 USE_CURSES = False
44 47 else:
45 48 # Curses on Solaris may not be complete, so we can't use it there
46 49 USE_CURSES = hasattr(curses,'initscr')
47 50
48 51 # Other IPython utilities
49 52 import IPython
50 53 from IPython.Itpl import Itpl,itpl,printpl
51 54 from IPython import DPyGetOpt, platutils
52 55 from IPython.generics import result_display
53 56 import IPython.ipapi
54 57 from IPython.external.path import path
55 58 if os.name == "nt":
56 59 from IPython.winconsole import get_console_size
57 60
58 61 try:
59 62 set
60 63 except:
61 64 from sets import Set as set
62 65
63 66
64 67 #****************************************************************************
65 68 # Exceptions
66 69 class Error(Exception):
67 70 """Base class for exceptions in this module."""
68 71 pass
69 72
70 73 #----------------------------------------------------------------------------
71 74 class IOStream:
72 75 def __init__(self,stream,fallback):
73 76 if not hasattr(stream,'write') or not hasattr(stream,'flush'):
74 77 stream = fallback
75 78 self.stream = stream
76 79 self._swrite = stream.write
77 80 self.flush = stream.flush
78 81
79 82 def write(self,data):
80 83 try:
81 84 self._swrite(data)
82 85 except:
83 86 try:
84 87 # print handles some unicode issues which may trip a plain
85 88 # write() call. Attempt to emulate write() by using a
86 89 # trailing comma
87 90 print >> self.stream, data,
88 91 except:
89 92 # if we get here, something is seriously broken.
90 93 print >> sys.stderr, \
91 94 'ERROR - failed to write data to stream:', self.stream
92 95
93 96 def close(self):
94 97 pass
95 98
96 99
97 100 class IOTerm:
98 101 """ Term holds the file or file-like objects for handling I/O operations.
99 102
100 103 These are normally just sys.stdin, sys.stdout and sys.stderr but for
101 104 Windows they can can replaced to allow editing the strings before they are
102 105 displayed."""
103 106
104 107 # In the future, having IPython channel all its I/O operations through
105 108 # this class will make it easier to embed it into other environments which
106 109 # are not a normal terminal (such as a GUI-based shell)
107 110 def __init__(self,cin=None,cout=None,cerr=None):
108 111 self.cin = IOStream(cin,sys.stdin)
109 112 self.cout = IOStream(cout,sys.stdout)
110 113 self.cerr = IOStream(cerr,sys.stderr)
111 114
112 115 # Global variable to be used for all I/O
113 116 Term = IOTerm()
114 117
115 118 import IPython.rlineimpl as readline
116 119 # Remake Term to use the readline i/o facilities
117 120 if sys.platform == 'win32' and readline.have_readline:
118 121
119 122 Term = IOTerm(cout=readline._outputfile,cerr=readline._outputfile)
120 123
121 124
122 125 #****************************************************************************
123 126 # Generic warning/error printer, used by everything else
124 127 def warn(msg,level=2,exit_val=1):
125 128 """Standard warning printer. Gives formatting consistency.
126 129
127 130 Output is sent to Term.cerr (sys.stderr by default).
128 131
129 132 Options:
130 133
131 134 -level(2): allows finer control:
132 135 0 -> Do nothing, dummy function.
133 136 1 -> Print message.
134 137 2 -> Print 'WARNING:' + message. (Default level).
135 138 3 -> Print 'ERROR:' + message.
136 139 4 -> Print 'FATAL ERROR:' + message and trigger a sys.exit(exit_val).
137 140
138 141 -exit_val (1): exit value returned by sys.exit() for a level 4
139 142 warning. Ignored for all other levels."""
140 143
141 144 if level>0:
142 145 header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
143 146 print >> Term.cerr, '%s%s' % (header[level],msg)
144 147 if level == 4:
145 148 print >> Term.cerr,'Exiting.\n'
146 149 sys.exit(exit_val)
147 150
148 151 def info(msg):
149 152 """Equivalent to warn(msg,level=1)."""
150 153
151 154 warn(msg,level=1)
152 155
153 156 def error(msg):
154 157 """Equivalent to warn(msg,level=3)."""
155 158
156 159 warn(msg,level=3)
157 160
158 161 def fatal(msg,exit_val=1):
159 162 """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
160 163
161 164 warn(msg,exit_val=exit_val,level=4)
162 165
163 166 #---------------------------------------------------------------------------
164 167 # Debugging routines
165 168 #
166 169 def debugx(expr,pre_msg=''):
167 170 """Print the value of an expression from the caller's frame.
168 171
169 172 Takes an expression, evaluates it in the caller's frame and prints both
170 173 the given expression and the resulting value (as well as a debug mark
171 174 indicating the name of the calling function. The input must be of a form
172 175 suitable for eval().
173 176
174 177 An optional message can be passed, which will be prepended to the printed
175 178 expr->value pair."""
176 179
177 180 cf = sys._getframe(1)
178 181 print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
179 182 eval(expr,cf.f_globals,cf.f_locals))
180 183
181 184 # deactivate it by uncommenting the following line, which makes it a no-op
182 185 #def debugx(expr,pre_msg=''): pass
183 186
184 187 #----------------------------------------------------------------------------
185 188 StringTypes = types.StringTypes
186 189
187 190 # Basic timing functionality
188 191
189 192 # If possible (Unix), use the resource module instead of time.clock()
190 193 try:
191 194 import resource
192 195 def clocku():
193 196 """clocku() -> floating point number
194 197
195 198 Return the *USER* CPU time in seconds since the start of the process.
196 199 This is done via a call to resource.getrusage, so it avoids the
197 200 wraparound problems in time.clock()."""
198 201
199 202 return resource.getrusage(resource.RUSAGE_SELF)[0]
200 203
201 204 def clocks():
202 205 """clocks() -> floating point number
203 206
204 207 Return the *SYSTEM* CPU time in seconds since the start of the process.
205 208 This is done via a call to resource.getrusage, so it avoids the
206 209 wraparound problems in time.clock()."""
207 210
208 211 return resource.getrusage(resource.RUSAGE_SELF)[1]
209 212
210 213 def clock():
211 214 """clock() -> floating point number
212 215
213 216 Return the *TOTAL USER+SYSTEM* CPU time in seconds since the start of
214 217 the process. This is done via a call to resource.getrusage, so it
215 218 avoids the wraparound problems in time.clock()."""
216 219
217 220 u,s = resource.getrusage(resource.RUSAGE_SELF)[:2]
218 221 return u+s
219 222
220 223 def clock2():
221 224 """clock2() -> (t_user,t_system)
222 225
223 226 Similar to clock(), but return a tuple of user/system times."""
224 227 return resource.getrusage(resource.RUSAGE_SELF)[:2]
225 228
226 229 except ImportError:
227 230 # There is no distinction of user/system time under windows, so we just use
228 231 # time.clock() for everything...
229 232 clocku = clocks = clock = time.clock
230 233 def clock2():
231 234 """Under windows, system CPU time can't be measured.
232 235
233 236 This just returns clock() and zero."""
234 237 return time.clock(),0.0
235 238
236 239 def timings_out(reps,func,*args,**kw):
237 240 """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
238 241
239 242 Execute a function reps times, return a tuple with the elapsed total
240 243 CPU time in seconds, the time per call and the function's output.
241 244
242 245 Under Unix, the return value is the sum of user+system time consumed by
243 246 the process, computed via the resource module. This prevents problems
244 247 related to the wraparound effect which the time.clock() function has.
245 248
246 249 Under Windows the return value is in wall clock seconds. See the
247 250 documentation for the time module for more details."""
248 251
249 252 reps = int(reps)
250 253 assert reps >=1, 'reps must be >= 1'
251 254 if reps==1:
252 255 start = clock()
253 256 out = func(*args,**kw)
254 257 tot_time = clock()-start
255 258 else:
256 259 rng = xrange(reps-1) # the last time is executed separately to store output
257 260 start = clock()
258 261 for dummy in rng: func(*args,**kw)
259 262 out = func(*args,**kw) # one last time
260 263 tot_time = clock()-start
261 264 av_time = tot_time / reps
262 265 return tot_time,av_time,out
263 266
264 267 def timings(reps,func,*args,**kw):
265 268 """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
266 269
267 270 Execute a function reps times, return a tuple with the elapsed total CPU
268 271 time in seconds and the time per call. These are just the first two values
269 272 in timings_out()."""
270 273
271 274 return timings_out(reps,func,*args,**kw)[0:2]
272 275
273 276 def timing(func,*args,**kw):
274 277 """timing(func,*args,**kw) -> t_total
275 278
276 279 Execute a function once, return the elapsed total CPU time in
277 280 seconds. This is just the first value in timings_out()."""
278 281
279 282 return timings_out(1,func,*args,**kw)[0]
280 283
281 284 #****************************************************************************
282 285 # file and system
283 286
284 287 def arg_split(s,posix=False):
285 288 """Split a command line's arguments in a shell-like manner.
286 289
287 290 This is a modified version of the standard library's shlex.split()
288 291 function, but with a default of posix=False for splitting, so that quotes
289 292 in inputs are respected."""
290 293
291 294 # XXX - there may be unicode-related problems here!!! I'm not sure that
292 295 # shlex is truly unicode-safe, so it might be necessary to do
293 296 #
294 297 # s = s.encode(sys.stdin.encoding)
295 298 #
296 299 # first, to ensure that shlex gets a normal string. Input from anyone who
297 300 # knows more about unicode and shlex than I would be good to have here...
298 301 lex = shlex.shlex(s, posix=posix)
299 302 lex.whitespace_split = True
300 303 return list(lex)
301 304
302 305 def system(cmd,verbose=0,debug=0,header=''):
303 306 """Execute a system command, return its exit status.
304 307
305 308 Options:
306 309
307 310 - verbose (0): print the command to be executed.
308 311
309 312 - debug (0): only print, do not actually execute.
310 313
311 314 - header (''): Header to print on screen prior to the executed command (it
312 315 is only prepended to the command, no newlines are added).
313 316
314 317 Note: a stateful version of this function is available through the
315 318 SystemExec class."""
316 319
317 320 stat = 0
318 321 if verbose or debug: print header+cmd
319 322 sys.stdout.flush()
320 323 if not debug: stat = os.system(cmd)
321 324 return stat
322 325
323 326 def abbrev_cwd():
324 327 """ Return abbreviated version of cwd, e.g. d:mydir """
325 328 cwd = os.getcwd().replace('\\','/')
326 329 drivepart = ''
327 330 tail = cwd
328 331 if sys.platform == 'win32':
329 332 if len(cwd) < 4:
330 333 return cwd
331 334 drivepart,tail = os.path.splitdrive(cwd)
332 335
333 336
334 337 parts = tail.split('/')
335 338 if len(parts) > 2:
336 339 tail = '/'.join(parts[-2:])
337 340
338 341 return (drivepart + (
339 342 cwd == '/' and '/' or tail))
340 343
341 344
342 345 # This function is used by ipython in a lot of places to make system calls.
343 346 # We need it to be slightly different under win32, due to the vagaries of
344 347 # 'network shares'. A win32 override is below.
345 348
346 349 def shell(cmd,verbose=0,debug=0,header=''):
347 350 """Execute a command in the system shell, always return None.
348 351
349 352 Options:
350 353
351 354 - verbose (0): print the command to be executed.
352 355
353 356 - debug (0): only print, do not actually execute.
354 357
355 358 - header (''): Header to print on screen prior to the executed command (it
356 359 is only prepended to the command, no newlines are added).
357 360
358 361 Note: this is similar to genutils.system(), but it returns None so it can
359 362 be conveniently used in interactive loops without getting the return value
360 363 (typically 0) printed many times."""
361 364
362 365 stat = 0
363 366 if verbose or debug: print header+cmd
364 367 # flush stdout so we don't mangle python's buffering
365 368 sys.stdout.flush()
366 369
367 370 if not debug:
368 371 platutils.set_term_title("IPy " + cmd)
369 372 os.system(cmd)
370 373 platutils.set_term_title("IPy " + abbrev_cwd())
371 374
372 375 # override shell() for win32 to deal with network shares
373 376 if os.name in ('nt','dos'):
374 377
375 378 shell_ori = shell
376 379
377 380 def shell(cmd,verbose=0,debug=0,header=''):
378 381 if os.getcwd().startswith(r"\\"):
379 382 path = os.getcwd()
380 383 # change to c drive (cannot be on UNC-share when issuing os.system,
381 384 # as cmd.exe cannot handle UNC addresses)
382 385 os.chdir("c:")
383 386 # issue pushd to the UNC-share and then run the command
384 387 try:
385 388 shell_ori('"pushd %s&&"'%path+cmd,verbose,debug,header)
386 389 finally:
387 390 os.chdir(path)
388 391 else:
389 392 shell_ori(cmd,verbose,debug,header)
390 393
391 394 shell.__doc__ = shell_ori.__doc__
392 395
393 396 def getoutput(cmd,verbose=0,debug=0,header='',split=0):
394 397 """Dummy substitute for perl's backquotes.
395 398
396 399 Executes a command and returns the output.
397 400
398 401 Accepts the same arguments as system(), plus:
399 402
400 403 - split(0): if true, the output is returned as a list split on newlines.
401 404
402 405 Note: a stateful version of this function is available through the
403 406 SystemExec class.
404 407
405 408 This is pretty much deprecated and rarely used,
406 409 genutils.getoutputerror may be what you need.
407 410
408 411 """
409 412
410 413 if verbose or debug: print header+cmd
411 414 if not debug:
412 415 output = os.popen(cmd).read()
413 416 # stipping last \n is here for backwards compat.
414 417 if output.endswith('\n'):
415 418 output = output[:-1]
416 419 if split:
417 420 return output.split('\n')
418 421 else:
419 422 return output
420 423
421 424 def getoutputerror(cmd,verbose=0,debug=0,header='',split=0):
422 425 """Return (standard output,standard error) of executing cmd in a shell.
423 426
424 427 Accepts the same arguments as system(), plus:
425 428
426 429 - split(0): if true, each of stdout/err is returned as a list split on
427 430 newlines.
428 431
429 432 Note: a stateful version of this function is available through the
430 433 SystemExec class."""
431 434
432 435 if verbose or debug: print header+cmd
433 436 if not cmd:
434 437 if split:
435 438 return [],[]
436 439 else:
437 440 return '',''
438 441 if not debug:
439 442 pin,pout,perr = os.popen3(cmd)
440 443 tout = pout.read().rstrip()
441 444 terr = perr.read().rstrip()
442 445 pin.close()
443 446 pout.close()
444 447 perr.close()
445 448 if split:
446 449 return tout.split('\n'),terr.split('\n')
447 450 else:
448 451 return tout,terr
449 452
450 453 # for compatibility with older naming conventions
451 454 xsys = system
452 455 bq = getoutput
453 456
454 457 class SystemExec:
455 458 """Access the system and getoutput functions through a stateful interface.
456 459
457 460 Note: here we refer to the system and getoutput functions from this
458 461 library, not the ones from the standard python library.
459 462
460 463 This class offers the system and getoutput functions as methods, but the
461 464 verbose, debug and header parameters can be set for the instance (at
462 465 creation time or later) so that they don't need to be specified on each
463 466 call.
464 467
465 468 For efficiency reasons, there's no way to override the parameters on a
466 469 per-call basis other than by setting instance attributes. If you need
467 470 local overrides, it's best to directly call system() or getoutput().
468 471
469 472 The following names are provided as alternate options:
470 473 - xsys: alias to system
471 474 - bq: alias to getoutput
472 475
473 476 An instance can then be created as:
474 477 >>> sysexec = SystemExec(verbose=1,debug=0,header='Calling: ')
475 478
476 479 And used as:
477 480 >>> sysexec.xsys('pwd')
478 481 >>> dirlist = sysexec.bq('ls -l')
479 482 """
480 483
481 484 def __init__(self,verbose=0,debug=0,header='',split=0):
482 485 """Specify the instance's values for verbose, debug and header."""
483 486 setattr_list(self,'verbose debug header split')
484 487
485 488 def system(self,cmd):
486 489 """Stateful interface to system(), with the same keyword parameters."""
487 490
488 491 system(cmd,self.verbose,self.debug,self.header)
489 492
490 493 def shell(self,cmd):
491 494 """Stateful interface to shell(), with the same keyword parameters."""
492 495
493 496 shell(cmd,self.verbose,self.debug,self.header)
494 497
495 498 xsys = system # alias
496 499
497 500 def getoutput(self,cmd):
498 501 """Stateful interface to getoutput()."""
499 502
500 503 return getoutput(cmd,self.verbose,self.debug,self.header,self.split)
501 504
502 505 def getoutputerror(self,cmd):
503 506 """Stateful interface to getoutputerror()."""
504 507
505 508 return getoutputerror(cmd,self.verbose,self.debug,self.header,self.split)
506 509
507 510 bq = getoutput # alias
508 511
509 512 #-----------------------------------------------------------------------------
510 513 def mutex_opts(dict,ex_op):
511 514 """Check for presence of mutually exclusive keys in a dict.
512 515
513 516 Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
514 517 for op1,op2 in ex_op:
515 518 if op1 in dict and op2 in dict:
516 519 raise ValueError,'\n*** ERROR in Arguments *** '\
517 520 'Options '+op1+' and '+op2+' are mutually exclusive.'
518 521
519 522 #-----------------------------------------------------------------------------
520 523 def get_py_filename(name):
521 524 """Return a valid python filename in the current directory.
522 525
523 526 If the given name is not a file, it adds '.py' and searches again.
524 527 Raises IOError with an informative message if the file isn't found."""
525 528
526 529 name = os.path.expanduser(name)
527 530 if not os.path.isfile(name) and not name.endswith('.py'):
528 531 name += '.py'
529 532 if os.path.isfile(name):
530 533 return name
531 534 else:
532 535 raise IOError,'File `%s` not found.' % name
533 536
534 537 #-----------------------------------------------------------------------------
535 538 def filefind(fname,alt_dirs = None):
536 539 """Return the given filename either in the current directory, if it
537 540 exists, or in a specified list of directories.
538 541
539 542 ~ expansion is done on all file and directory names.
540 543
541 544 Upon an unsuccessful search, raise an IOError exception."""
542 545
543 546 if alt_dirs is None:
544 547 try:
545 548 alt_dirs = get_home_dir()
546 549 except HomeDirError:
547 550 alt_dirs = os.getcwd()
548 551 search = [fname] + list_strings(alt_dirs)
549 552 search = map(os.path.expanduser,search)
550 553 #print 'search list for',fname,'list:',search # dbg
551 554 fname = search[0]
552 555 if os.path.isfile(fname):
553 556 return fname
554 557 for direc in search[1:]:
555 558 testname = os.path.join(direc,fname)
556 559 #print 'testname',testname # dbg
557 560 if os.path.isfile(testname):
558 561 return testname
559 562 raise IOError,'File' + `fname` + \
560 563 ' not found in current or supplied directories:' + `alt_dirs`
561 564
562 565 #----------------------------------------------------------------------------
563 566 def file_read(filename):
564 567 """Read a file and close it. Returns the file source."""
565 568 fobj = open(filename,'r');
566 569 source = fobj.read();
567 570 fobj.close()
568 571 return source
569 572
570 573 def file_readlines(filename):
571 574 """Read a file and close it. Returns the file source using readlines()."""
572 575 fobj = open(filename,'r');
573 576 lines = fobj.readlines();
574 577 fobj.close()
575 578 return lines
576 579
577 580 #----------------------------------------------------------------------------
578 581 def target_outdated(target,deps):
579 582 """Determine whether a target is out of date.
580 583
581 584 target_outdated(target,deps) -> 1/0
582 585
583 586 deps: list of filenames which MUST exist.
584 587 target: single filename which may or may not exist.
585 588
586 589 If target doesn't exist or is older than any file listed in deps, return
587 590 true, otherwise return false.
588 591 """
589 592 try:
590 593 target_time = os.path.getmtime(target)
591 594 except os.error:
592 595 return 1
593 596 for dep in deps:
594 597 dep_time = os.path.getmtime(dep)
595 598 if dep_time > target_time:
596 599 #print "For target",target,"Dep failed:",dep # dbg
597 600 #print "times (dep,tar):",dep_time,target_time # dbg
598 601 return 1
599 602 return 0
600 603
601 604 #-----------------------------------------------------------------------------
602 605 def target_update(target,deps,cmd):
603 606 """Update a target with a given command given a list of dependencies.
604 607
605 608 target_update(target,deps,cmd) -> runs cmd if target is outdated.
606 609
607 610 This is just a wrapper around target_outdated() which calls the given
608 611 command if target is outdated."""
609 612
610 613 if target_outdated(target,deps):
611 614 xsys(cmd)
612 615
613 616 #----------------------------------------------------------------------------
614 617 def unquote_ends(istr):
615 618 """Remove a single pair of quotes from the endpoints of a string."""
616 619
617 620 if not istr:
618 621 return istr
619 622 if (istr[0]=="'" and istr[-1]=="'") or \
620 623 (istr[0]=='"' and istr[-1]=='"'):
621 624 return istr[1:-1]
622 625 else:
623 626 return istr
624 627
625 628 #----------------------------------------------------------------------------
626 629 def process_cmdline(argv,names=[],defaults={},usage=''):
627 630 """ Process command-line options and arguments.
628 631
629 632 Arguments:
630 633
631 634 - argv: list of arguments, typically sys.argv.
632 635
633 636 - names: list of option names. See DPyGetOpt docs for details on options
634 637 syntax.
635 638
636 639 - defaults: dict of default values.
637 640
638 641 - usage: optional usage notice to print if a wrong argument is passed.
639 642
640 643 Return a dict of options and a list of free arguments."""
641 644
642 645 getopt = DPyGetOpt.DPyGetOpt()
643 646 getopt.setIgnoreCase(0)
644 647 getopt.parseConfiguration(names)
645 648
646 649 try:
647 650 getopt.processArguments(argv)
648 651 except DPyGetOpt.ArgumentError, exc:
649 652 print usage
650 653 warn('"%s"' % exc,level=4)
651 654
652 655 defaults.update(getopt.optionValues)
653 656 args = getopt.freeValues
654 657
655 658 return defaults,args
656 659
657 660 #----------------------------------------------------------------------------
658 661 def optstr2types(ostr):
659 662 """Convert a string of option names to a dict of type mappings.
660 663
661 664 optstr2types(str) -> {None:'string_opts',int:'int_opts',float:'float_opts'}
662 665
663 666 This is used to get the types of all the options in a string formatted
664 667 with the conventions of DPyGetOpt. The 'type' None is used for options
665 668 which are strings (they need no further conversion). This function's main
666 669 use is to get a typemap for use with read_dict().
667 670 """
668 671
669 672 typeconv = {None:'',int:'',float:''}
670 673 typemap = {'s':None,'i':int,'f':float}
671 674 opt_re = re.compile(r'([\w]*)([^:=]*:?=?)([sif]?)')
672 675
673 676 for w in ostr.split():
674 677 oname,alias,otype = opt_re.match(w).groups()
675 678 if otype == '' or alias == '!': # simple switches are integers too
676 679 otype = 'i'
677 680 typeconv[typemap[otype]] += oname + ' '
678 681 return typeconv
679 682
680 683 #----------------------------------------------------------------------------
681 684 def read_dict(filename,type_conv=None,**opt):
682 685
683 686 """Read a dictionary of key=value pairs from an input file, optionally
684 687 performing conversions on the resulting values.
685 688
686 689 read_dict(filename,type_conv,**opt) -> dict
687 690
688 691 Only one value per line is accepted, the format should be
689 692 # optional comments are ignored
690 693 key value\n
691 694
692 695 Args:
693 696
694 697 - type_conv: A dictionary specifying which keys need to be converted to
695 698 which types. By default all keys are read as strings. This dictionary
696 699 should have as its keys valid conversion functions for strings
697 700 (int,long,float,complex, or your own). The value for each key
698 701 (converter) should be a whitespace separated string containing the names
699 702 of all the entries in the file to be converted using that function. For
700 703 keys to be left alone, use None as the conversion function (only needed
701 704 with purge=1, see below).
702 705
703 706 - opt: dictionary with extra options as below (default in parens)
704 707
705 708 purge(0): if set to 1, all keys *not* listed in type_conv are purged out
706 709 of the dictionary to be returned. If purge is going to be used, the
707 710 set of keys to be left as strings also has to be explicitly specified
708 711 using the (non-existent) conversion function None.
709 712
710 713 fs(None): field separator. This is the key/value separator to be used
711 714 when parsing the file. The None default means any whitespace [behavior
712 715 of string.split()].
713 716
714 717 strip(0): if 1, strip string values of leading/trailinig whitespace.
715 718
716 719 warn(1): warning level if requested keys are not found in file.
717 720 - 0: silently ignore.
718 721 - 1: inform but proceed.
719 722 - 2: raise KeyError exception.
720 723
721 724 no_empty(0): if 1, remove keys with whitespace strings as a value.
722 725
723 726 unique([]): list of keys (or space separated string) which can't be
724 727 repeated. If one such key is found in the file, each new instance
725 728 overwrites the previous one. For keys not listed here, the behavior is
726 729 to make a list of all appearances.
727 730
728 731 Example:
729 732 If the input file test.ini has:
730 733 i 3
731 734 x 4.5
732 735 y 5.5
733 736 s hi ho
734 737 Then:
735 738
736 739 >>> type_conv={int:'i',float:'x',None:'s'}
737 740 >>> read_dict('test.ini')
738 741 {'i': '3', 's': 'hi ho', 'x': '4.5', 'y': '5.5'}
739 742 >>> read_dict('test.ini',type_conv)
740 743 {'i': 3, 's': 'hi ho', 'x': 4.5, 'y': '5.5'}
741 744 >>> read_dict('test.ini',type_conv,purge=1)
742 745 {'i': 3, 's': 'hi ho', 'x': 4.5}
743 746 """
744 747
745 748 # starting config
746 749 opt.setdefault('purge',0)
747 750 opt.setdefault('fs',None) # field sep defaults to any whitespace
748 751 opt.setdefault('strip',0)
749 752 opt.setdefault('warn',1)
750 753 opt.setdefault('no_empty',0)
751 754 opt.setdefault('unique','')
752 755 if type(opt['unique']) in StringTypes:
753 756 unique_keys = qw(opt['unique'])
754 757 elif type(opt['unique']) in (types.TupleType,types.ListType):
755 758 unique_keys = opt['unique']
756 759 else:
757 760 raise ValueError, 'Unique keys must be given as a string, List or Tuple'
758 761
759 762 dict = {}
760 763 # first read in table of values as strings
761 764 file = open(filename,'r')
762 765 for line in file.readlines():
763 766 line = line.strip()
764 767 if len(line) and line[0]=='#': continue
765 768 if len(line)>0:
766 769 lsplit = line.split(opt['fs'],1)
767 770 try:
768 771 key,val = lsplit
769 772 except ValueError:
770 773 key,val = lsplit[0],''
771 774 key = key.strip()
772 775 if opt['strip']: val = val.strip()
773 776 if val == "''" or val == '""': val = ''
774 777 if opt['no_empty'] and (val=='' or val.isspace()):
775 778 continue
776 779 # if a key is found more than once in the file, build a list
777 780 # unless it's in the 'unique' list. In that case, last found in file
778 781 # takes precedence. User beware.
779 782 try:
780 783 if dict[key] and key in unique_keys:
781 784 dict[key] = val
782 785 elif type(dict[key]) is types.ListType:
783 786 dict[key].append(val)
784 787 else:
785 788 dict[key] = [dict[key],val]
786 789 except KeyError:
787 790 dict[key] = val
788 791 # purge if requested
789 792 if opt['purge']:
790 793 accepted_keys = qwflat(type_conv.values())
791 794 for key in dict.keys():
792 795 if key in accepted_keys: continue
793 796 del(dict[key])
794 797 # now convert if requested
795 798 if type_conv==None: return dict
796 799 conversions = type_conv.keys()
797 800 try: conversions.remove(None)
798 801 except: pass
799 802 for convert in conversions:
800 803 for val in qw(type_conv[convert]):
801 804 try:
802 805 dict[val] = convert(dict[val])
803 806 except KeyError,e:
804 807 if opt['warn'] == 0:
805 808 pass
806 809 elif opt['warn'] == 1:
807 810 print >>sys.stderr, 'Warning: key',val,\
808 811 'not found in file',filename
809 812 elif opt['warn'] == 2:
810 813 raise KeyError,e
811 814 else:
812 815 raise ValueError,'Warning level must be 0,1 or 2'
813 816
814 817 return dict
815 818
816 819 #----------------------------------------------------------------------------
817 820 def flag_calls(func):
818 821 """Wrap a function to detect and flag when it gets called.
819 822
820 823 This is a decorator which takes a function and wraps it in a function with
821 824 a 'called' attribute. wrapper.called is initialized to False.
822 825
823 826 The wrapper.called attribute is set to False right before each call to the
824 827 wrapped function, so if the call fails it remains False. After the call
825 828 completes, wrapper.called is set to True and the output is returned.
826 829
827 830 Testing for truth in wrapper.called allows you to determine if a call to
828 831 func() was attempted and succeeded."""
829 832
830 833 def wrapper(*args,**kw):
831 834 wrapper.called = False
832 835 out = func(*args,**kw)
833 836 wrapper.called = True
834 837 return out
835 838
836 839 wrapper.called = False
837 840 wrapper.__doc__ = func.__doc__
838 841 return wrapper
839 842
840 843 #----------------------------------------------------------------------------
841 844 def dhook_wrap(func,*a,**k):
842 845 """Wrap a function call in a sys.displayhook controller.
843 846
844 847 Returns a wrapper around func which calls func, with all its arguments and
845 848 keywords unmodified, using the default sys.displayhook. Since IPython
846 849 modifies sys.displayhook, it breaks the behavior of certain systems that
847 850 rely on the default behavior, notably doctest.
848 851 """
849 852
850 853 def f(*a,**k):
851 854
852 855 dhook_s = sys.displayhook
853 856 sys.displayhook = sys.__displayhook__
854 857 try:
855 858 out = func(*a,**k)
856 859 finally:
857 860 sys.displayhook = dhook_s
858 861
859 862 return out
860 863
861 864 f.__doc__ = func.__doc__
862 865 return f
863 866
864 867 #----------------------------------------------------------------------------
865 868 def doctest_reload():
866 869 """Properly reload doctest to reuse it interactively.
867 870
868 871 This routine:
869 872
870 873 - reloads doctest
871 874
872 875 - resets its global 'master' attribute to None, so that multiple uses of
873 876 the module interactively don't produce cumulative reports.
874 877
875 878 - Monkeypatches its core test runner method to protect it from IPython's
876 879 modified displayhook. Doctest expects the default displayhook behavior
877 880 deep down, so our modification breaks it completely. For this reason, a
878 881 hard monkeypatch seems like a reasonable solution rather than asking
879 882 users to manually use a different doctest runner when under IPython."""
880 883
881 884 import doctest
882 885 reload(doctest)
883 886 doctest.master=None
884 887
885 888 try:
886 889 doctest.DocTestRunner
887 890 except AttributeError:
888 891 # This is only for python 2.3 compatibility, remove once we move to
889 892 # 2.4 only.
890 893 pass
891 894 else:
892 895 doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
893 896
894 897 #----------------------------------------------------------------------------
895 898 class HomeDirError(Error):
896 899 pass
897 900
898 901 def get_home_dir():
899 902 """Return the closest possible equivalent to a 'home' directory.
900 903
901 904 We first try $HOME. Absent that, on NT it's $HOMEDRIVE\$HOMEPATH.
902 905
903 906 Currently only Posix and NT are implemented, a HomeDirError exception is
904 907 raised for all other OSes. """
905 908
906 909 isdir = os.path.isdir
907 910 env = os.environ
908 911
909 912 # first, check py2exe distribution root directory for _ipython.
910 913 # This overrides all. Normally does not exist.
911 914
912 915 if '\\library.zip\\' in IPython.__file__.lower():
913 916 root, rest = IPython.__file__.lower().split('library.zip')
914 917 if isdir(root + '_ipython'):
915 918 os.environ["IPYKITROOT"] = root.rstrip('\\')
916 919 return root
917 920
918 921 try:
919 922 homedir = env['HOME']
920 923 if not isdir(homedir):
921 924 # in case a user stuck some string which does NOT resolve to a
922 925 # valid path, it's as good as if we hadn't foud it
923 926 raise KeyError
924 927 return homedir
925 928 except KeyError:
926 929 if os.name == 'posix':
927 930 raise HomeDirError,'undefined $HOME, IPython can not proceed.'
928 931 elif os.name == 'nt':
929 932 # For some strange reason, win9x returns 'nt' for os.name.
930 933 try:
931 934 homedir = os.path.join(env['HOMEDRIVE'],env['HOMEPATH'])
932 935 if not isdir(homedir):
933 936 homedir = os.path.join(env['USERPROFILE'])
934 937 if not isdir(homedir):
935 938 raise HomeDirError
936 939 return homedir
937 940 except:
938 941 try:
939 942 # Use the registry to get the 'My Documents' folder.
940 943 import _winreg as wreg
941 944 key = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
942 945 "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
943 946 homedir = wreg.QueryValueEx(key,'Personal')[0]
944 947 key.Close()
945 948 if not isdir(homedir):
946 949 e = ('Invalid "Personal" folder registry key '
947 950 'typically "My Documents".\n'
948 951 'Value: %s\n'
949 952 'This is not a valid directory on your system.' %
950 953 homedir)
951 954 raise HomeDirError(e)
952 955 return homedir
953 956 except HomeDirError:
954 957 raise
955 958 except:
956 959 return 'C:\\'
957 960 elif os.name == 'dos':
958 961 # Desperate, may do absurd things in classic MacOS. May work under DOS.
959 962 return 'C:\\'
960 963 else:
961 964 raise HomeDirError,'support for your operating system not implemented.'
962 965
963 966 #****************************************************************************
964 967 # strings and text
965 968
966 969 class LSString(str):
967 970 """String derivative with a special access attributes.
968 971
969 972 These are normal strings, but with the special attributes:
970 973
971 974 .l (or .list) : value as list (split on newlines).
972 975 .n (or .nlstr): original value (the string itself).
973 976 .s (or .spstr): value as whitespace-separated string.
974 977 .p (or .paths): list of path objects
975 978
976 979 Any values which require transformations are computed only once and
977 980 cached.
978 981
979 982 Such strings are very useful to efficiently interact with the shell, which
980 983 typically only understands whitespace-separated options for commands."""
981 984
982 985 def get_list(self):
983 986 try:
984 987 return self.__list
985 988 except AttributeError:
986 989 self.__list = self.split('\n')
987 990 return self.__list
988 991
989 992 l = list = property(get_list)
990 993
991 994 def get_spstr(self):
992 995 try:
993 996 return self.__spstr
994 997 except AttributeError:
995 998 self.__spstr = self.replace('\n',' ')
996 999 return self.__spstr
997 1000
998 1001 s = spstr = property(get_spstr)
999 1002
1000 1003 def get_nlstr(self):
1001 1004 return self
1002 1005
1003 1006 n = nlstr = property(get_nlstr)
1004 1007
1005 1008 def get_paths(self):
1006 1009 try:
1007 1010 return self.__paths
1008 1011 except AttributeError:
1009 1012 self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
1010 1013 return self.__paths
1011 1014
1012 1015 p = paths = property(get_paths)
1013 1016
1014 1017 def print_lsstring(arg):
1015 1018 """ Prettier (non-repr-like) and more informative printer for LSString """
1016 1019 print "LSString (.p, .n, .l, .s available). Value:"
1017 1020 print arg
1018 1021
1019 1022 print_lsstring = result_display.when_type(LSString)(print_lsstring)
1020 1023
1021 1024 #----------------------------------------------------------------------------
1022 1025 class SList(list):
1023 1026 """List derivative with a special access attributes.
1024 1027
1025 1028 These are normal lists, but with the special attributes:
1026 1029
1027 1030 .l (or .list) : value as list (the list itself).
1028 1031 .n (or .nlstr): value as a string, joined on newlines.
1029 1032 .s (or .spstr): value as a string, joined on spaces.
1030 1033 .p (or .paths): list of path objects
1031 1034
1032 1035 Any values which require transformations are computed only once and
1033 1036 cached."""
1034 1037
1035 1038 def get_list(self):
1036 1039 return self
1037 1040
1038 1041 l = list = property(get_list)
1039 1042
1040 1043 def get_spstr(self):
1041 1044 try:
1042 1045 return self.__spstr
1043 1046 except AttributeError:
1044 1047 self.__spstr = ' '.join(self)
1045 1048 return self.__spstr
1046 1049
1047 1050 s = spstr = property(get_spstr)
1048 1051
1049 1052 def get_nlstr(self):
1050 1053 try:
1051 1054 return self.__nlstr
1052 1055 except AttributeError:
1053 1056 self.__nlstr = '\n'.join(self)
1054 1057 return self.__nlstr
1055 1058
1056 1059 n = nlstr = property(get_nlstr)
1057 1060
1058 1061 def get_paths(self):
1059 1062 try:
1060 1063 return self.__paths
1061 1064 except AttributeError:
1062 1065 self.__paths = [path(p) for p in self if os.path.exists(p)]
1063 1066 return self.__paths
1064 1067
1065 1068 p = paths = property(get_paths)
1066 1069
1067 1070 def grep(self, pattern, prune = False, field = None):
1068 1071 """ Return all strings matching 'pattern' (a regex or callable)
1069 1072
1070 1073 This is case-insensitive. If prune is true, return all items
1071 1074 NOT matching the pattern.
1072 1075
1073 1076 If field is specified, the match must occur in the specified
1074 1077 whitespace-separated field.
1075 1078
1076 1079 Examples::
1077 1080
1078 1081 a.grep( lambda x: x.startswith('C') )
1079 1082 a.grep('Cha.*log', prune=1)
1080 1083 a.grep('chm', field=-1)
1081 1084 """
1082 1085
1083 1086 def match_target(s):
1084 1087 if field is None:
1085 1088 return s
1086 1089 parts = s.split()
1087 1090 try:
1088 1091 tgt = parts[field]
1089 1092 return tgt
1090 1093 except IndexError:
1091 1094 return ""
1092 1095
1093 1096 if isinstance(pattern, basestring):
1094 1097 pred = lambda x : re.search(pattern, x, re.IGNORECASE)
1095 1098 else:
1096 1099 pred = pattern
1097 1100 if not prune:
1098 1101 return SList([el for el in self if pred(match_target(el))])
1099 1102 else:
1100 1103 return SList([el for el in self if not pred(match_target(el))])
1101 1104 def fields(self, *fields):
1102 1105 """ Collect whitespace-separated fields from string list
1103 1106
1104 1107 Allows quick awk-like usage of string lists.
1105 1108
1106 1109 Example data (in var a, created by 'a = !ls -l')::
1107 1110 -rwxrwxrwx 1 ville None 18 Dec 14 2006 ChangeLog
1108 1111 drwxrwxrwx+ 6 ville None 0 Oct 24 18:05 IPython
1109 1112
1110 1113 a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
1111 1114 a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
1112 1115 (note the joining by space).
1113 1116 a.fields(-1) is ['ChangeLog', 'IPython']
1114 1117
1115 1118 IndexErrors are ignored.
1116 1119
1117 1120 Without args, fields() just split()'s the strings.
1118 1121 """
1119 1122 if len(fields) == 0:
1120 1123 return [el.split() for el in self]
1121 1124
1122 1125 res = SList()
1123 1126 for el in [f.split() for f in self]:
1124 1127 lineparts = []
1125 1128
1126 1129 for fd in fields:
1127 1130 try:
1128 1131 lineparts.append(el[fd])
1129 1132 except IndexError:
1130 1133 pass
1131 1134 if lineparts:
1132 1135 res.append(" ".join(lineparts))
1133 1136
1134 1137 return res
1135 1138
1136 1139
1137 1140
1138 1141
1139 1142
1140 1143 def print_slist(arg):
1141 1144 """ Prettier (non-repr-like) and more informative printer for SList """
1142 1145 print "SList (.p, .n, .l, .s, .grep(), .fields() available). Value:"
1143 1146 nlprint(arg)
1144 1147
1145 1148 print_slist = result_display.when_type(SList)(print_slist)
1146 1149
1147 1150
1148 1151
1149 1152 #----------------------------------------------------------------------------
1150 1153 def esc_quotes(strng):
1151 1154 """Return the input string with single and double quotes escaped out"""
1152 1155
1153 1156 return strng.replace('"','\\"').replace("'","\\'")
1154 1157
1155 1158 #----------------------------------------------------------------------------
1156 1159 def make_quoted_expr(s):
1157 1160 """Return string s in appropriate quotes, using raw string if possible.
1158 1161
1159 1162 Effectively this turns string: cd \ao\ao\
1160 1163 to: r"cd \ao\ao\_"[:-1]
1161 1164
1162 1165 Note the use of raw string and padding at the end to allow trailing backslash.
1163 1166
1164 1167 """
1165 1168
1166 1169 tail = ''
1167 1170 tailpadding = ''
1168 1171 raw = ''
1169 1172 if "\\" in s:
1170 1173 raw = 'r'
1171 1174 if s.endswith('\\'):
1172 1175 tail = '[:-1]'
1173 1176 tailpadding = '_'
1174 1177 if '"' not in s:
1175 1178 quote = '"'
1176 1179 elif "'" not in s:
1177 1180 quote = "'"
1178 1181 elif '"""' not in s and not s.endswith('"'):
1179 1182 quote = '"""'
1180 1183 elif "'''" not in s and not s.endswith("'"):
1181 1184 quote = "'''"
1182 1185 else:
1183 1186 # give up, backslash-escaped string will do
1184 1187 return '"%s"' % esc_quotes(s)
1185 1188 res = raw + quote + s + tailpadding + quote + tail
1186 1189 return res
1187 1190
1188 1191
1189 1192 #----------------------------------------------------------------------------
1190 1193 def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'):
1191 1194 """Take multiple lines of input.
1192 1195
1193 1196 A list with each line of input as a separate element is returned when a
1194 1197 termination string is entered (defaults to a single '.'). Input can also
1195 1198 terminate via EOF (^D in Unix, ^Z-RET in Windows).
1196 1199
1197 1200 Lines of input which end in \\ are joined into single entries (and a
1198 1201 secondary continuation prompt is issued as long as the user terminates
1199 1202 lines with \\). This allows entering very long strings which are still
1200 1203 meant to be treated as single entities.
1201 1204 """
1202 1205
1203 1206 try:
1204 1207 if header:
1205 1208 header += '\n'
1206 1209 lines = [raw_input(header + ps1)]
1207 1210 except EOFError:
1208 1211 return []
1209 1212 terminate = [terminate_str]
1210 1213 try:
1211 1214 while lines[-1:] != terminate:
1212 1215 new_line = raw_input(ps1)
1213 1216 while new_line.endswith('\\'):
1214 1217 new_line = new_line[:-1] + raw_input(ps2)
1215 1218 lines.append(new_line)
1216 1219
1217 1220 return lines[:-1] # don't return the termination command
1218 1221 except EOFError:
1219 1222 print
1220 1223 return lines
1221 1224
1222 1225 #----------------------------------------------------------------------------
1223 1226 def raw_input_ext(prompt='', ps2='... '):
1224 1227 """Similar to raw_input(), but accepts extended lines if input ends with \\."""
1225 1228
1226 1229 line = raw_input(prompt)
1227 1230 while line.endswith('\\'):
1228 1231 line = line[:-1] + raw_input(ps2)
1229 1232 return line
1230 1233
1231 1234 #----------------------------------------------------------------------------
1232 1235 def ask_yes_no(prompt,default=None):
1233 1236 """Asks a question and returns a boolean (y/n) answer.
1234 1237
1235 1238 If default is given (one of 'y','n'), it is used if the user input is
1236 1239 empty. Otherwise the question is repeated until an answer is given.
1237 1240
1238 1241 An EOF is treated as the default answer. If there is no default, an
1239 1242 exception is raised to prevent infinite loops.
1240 1243
1241 1244 Valid answers are: y/yes/n/no (match is not case sensitive)."""
1242 1245
1243 1246 answers = {'y':True,'n':False,'yes':True,'no':False}
1244 1247 ans = None
1245 1248 while ans not in answers.keys():
1246 1249 try:
1247 1250 ans = raw_input(prompt+' ').lower()
1248 1251 if not ans: # response was an empty string
1249 1252 ans = default
1250 1253 except KeyboardInterrupt:
1251 1254 pass
1252 1255 except EOFError:
1253 1256 if default in answers.keys():
1254 1257 ans = default
1255 1258 print
1256 1259 else:
1257 1260 raise
1258 1261
1259 1262 return answers[ans]
1260 1263
1261 1264 #----------------------------------------------------------------------------
1262 1265 def marquee(txt='',width=78,mark='*'):
1263 1266 """Return the input string centered in a 'marquee'."""
1264 1267 if not txt:
1265 1268 return (mark*width)[:width]
1266 1269 nmark = (width-len(txt)-2)/len(mark)/2
1267 1270 if nmark < 0: nmark =0
1268 1271 marks = mark*nmark
1269 1272 return '%s %s %s' % (marks,txt,marks)
1270 1273
1271 1274 #----------------------------------------------------------------------------
1272 1275 class EvalDict:
1273 1276 """
1274 1277 Emulate a dict which evaluates its contents in the caller's frame.
1275 1278
1276 1279 Usage:
1277 1280 >>>number = 19
1278 1281 >>>text = "python"
1279 1282 >>>print "%(text.capitalize())s %(number/9.0).1f rules!" % EvalDict()
1280 1283 """
1281 1284
1282 1285 # This version is due to sismex01@hebmex.com on c.l.py, and is basically a
1283 1286 # modified (shorter) version of:
1284 1287 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66018 by
1285 1288 # Skip Montanaro (skip@pobox.com).
1286 1289
1287 1290 def __getitem__(self, name):
1288 1291 frame = sys._getframe(1)
1289 1292 return eval(name, frame.f_globals, frame.f_locals)
1290 1293
1291 1294 EvalString = EvalDict # for backwards compatibility
1292 1295 #----------------------------------------------------------------------------
1293 1296 def qw(words,flat=0,sep=None,maxsplit=-1):
1294 1297 """Similar to Perl's qw() operator, but with some more options.
1295 1298
1296 1299 qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
1297 1300
1298 1301 words can also be a list itself, and with flat=1, the output will be
1299 1302 recursively flattened. Examples:
1300 1303
1301 1304 >>> qw('1 2')
1302 1305 ['1', '2']
1303 1306 >>> qw(['a b','1 2',['m n','p q']])
1304 1307 [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
1305 1308 >>> qw(['a b','1 2',['m n','p q']],flat=1)
1306 1309 ['a', 'b', '1', '2', 'm', 'n', 'p', 'q'] """
1307 1310
1308 1311 if type(words) in StringTypes:
1309 1312 return [word.strip() for word in words.split(sep,maxsplit)
1310 1313 if word and not word.isspace() ]
1311 1314 if flat:
1312 1315 return flatten(map(qw,words,[1]*len(words)))
1313 1316 return map(qw,words)
1314 1317
1315 1318 #----------------------------------------------------------------------------
1316 1319 def qwflat(words,sep=None,maxsplit=-1):
1317 1320 """Calls qw(words) in flat mode. It's just a convenient shorthand."""
1318 1321 return qw(words,1,sep,maxsplit)
1319 1322
1320 1323 #----------------------------------------------------------------------------
1321 1324 def qw_lol(indata):
1322 1325 """qw_lol('a b') -> [['a','b']],
1323 1326 otherwise it's just a call to qw().
1324 1327
1325 1328 We need this to make sure the modules_some keys *always* end up as a
1326 1329 list of lists."""
1327 1330
1328 1331 if type(indata) in StringTypes:
1329 1332 return [qw(indata)]
1330 1333 else:
1331 1334 return qw(indata)
1332 1335
1333 1336 #-----------------------------------------------------------------------------
1334 1337 def list_strings(arg):
1335 1338 """Always return a list of strings, given a string or list of strings
1336 1339 as input."""
1337 1340
1338 1341 if type(arg) in StringTypes: return [arg]
1339 1342 else: return arg
1340 1343
1341 1344 #----------------------------------------------------------------------------
1342 1345 def grep(pat,list,case=1):
1343 1346 """Simple minded grep-like function.
1344 1347 grep(pat,list) returns occurrences of pat in list, None on failure.
1345 1348
1346 1349 It only does simple string matching, with no support for regexps. Use the
1347 1350 option case=0 for case-insensitive matching."""
1348 1351
1349 1352 # This is pretty crude. At least it should implement copying only references
1350 1353 # to the original data in case it's big. Now it copies the data for output.
1351 1354 out=[]
1352 1355 if case:
1353 1356 for term in list:
1354 1357 if term.find(pat)>-1: out.append(term)
1355 1358 else:
1356 1359 lpat=pat.lower()
1357 1360 for term in list:
1358 1361 if term.lower().find(lpat)>-1: out.append(term)
1359 1362
1360 1363 if len(out): return out
1361 1364 else: return None
1362 1365
1363 1366 #----------------------------------------------------------------------------
1364 1367 def dgrep(pat,*opts):
1365 1368 """Return grep() on dir()+dir(__builtins__).
1366 1369
1367 1370 A very common use of grep() when working interactively."""
1368 1371
1369 1372 return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
1370 1373
1371 1374 #----------------------------------------------------------------------------
1372 1375 def idgrep(pat):
1373 1376 """Case-insensitive dgrep()"""
1374 1377
1375 1378 return dgrep(pat,0)
1376 1379
1377 1380 #----------------------------------------------------------------------------
1378 1381 def igrep(pat,list):
1379 1382 """Synonym for case-insensitive grep."""
1380 1383
1381 1384 return grep(pat,list,case=0)
1382 1385
1383 1386 #----------------------------------------------------------------------------
1384 1387 def indent(str,nspaces=4,ntabs=0):
1385 1388 """Indent a string a given number of spaces or tabstops.
1386 1389
1387 1390 indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
1388 1391 """
1389 1392 if str is None:
1390 1393 return
1391 1394 ind = '\t'*ntabs+' '*nspaces
1392 1395 outstr = '%s%s' % (ind,str.replace(os.linesep,os.linesep+ind))
1393 1396 if outstr.endswith(os.linesep+ind):
1394 1397 return outstr[:-len(ind)]
1395 1398 else:
1396 1399 return outstr
1397 1400
1398 1401 #-----------------------------------------------------------------------------
1399 1402 def native_line_ends(filename,backup=1):
1400 1403 """Convert (in-place) a file to line-ends native to the current OS.
1401 1404
1402 1405 If the optional backup argument is given as false, no backup of the
1403 1406 original file is left. """
1404 1407
1405 1408 backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
1406 1409
1407 1410 bak_filename = filename + backup_suffixes[os.name]
1408 1411
1409 1412 original = open(filename).read()
1410 1413 shutil.copy2(filename,bak_filename)
1411 1414 try:
1412 1415 new = open(filename,'wb')
1413 1416 new.write(os.linesep.join(original.splitlines()))
1414 1417 new.write(os.linesep) # ALWAYS put an eol at the end of the file
1415 1418 new.close()
1416 1419 except:
1417 1420 os.rename(bak_filename,filename)
1418 1421 if not backup:
1419 1422 try:
1420 1423 os.remove(bak_filename)
1421 1424 except:
1422 1425 pass
1423 1426
1424 1427 #----------------------------------------------------------------------------
1425 1428 def get_pager_cmd(pager_cmd = None):
1426 1429 """Return a pager command.
1427 1430
1428 1431 Makes some attempts at finding an OS-correct one."""
1429 1432
1430 1433 if os.name == 'posix':
1431 1434 default_pager_cmd = 'less -r' # -r for color control sequences
1432 1435 elif os.name in ['nt','dos']:
1433 1436 default_pager_cmd = 'type'
1434 1437
1435 1438 if pager_cmd is None:
1436 1439 try:
1437 1440 pager_cmd = os.environ['PAGER']
1438 1441 except:
1439 1442 pager_cmd = default_pager_cmd
1440 1443 return pager_cmd
1441 1444
1442 1445 #-----------------------------------------------------------------------------
1443 1446 def get_pager_start(pager,start):
1444 1447 """Return the string for paging files with an offset.
1445 1448
1446 1449 This is the '+N' argument which less and more (under Unix) accept.
1447 1450 """
1448 1451
1449 1452 if pager in ['less','more']:
1450 1453 if start:
1451 1454 start_string = '+' + str(start)
1452 1455 else:
1453 1456 start_string = ''
1454 1457 else:
1455 1458 start_string = ''
1456 1459 return start_string
1457 1460
1458 1461 #----------------------------------------------------------------------------
1459 1462 # (X)emacs on W32 doesn't like to be bypassed with msvcrt.getch()
1460 1463 if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
1461 1464 import msvcrt
1462 1465 def page_more():
1463 1466 """ Smart pausing between pages
1464 1467
1465 1468 @return: True if need print more lines, False if quit
1466 1469 """
1467 1470 Term.cout.write('---Return to continue, q to quit--- ')
1468 1471 ans = msvcrt.getch()
1469 1472 if ans in ("q", "Q"):
1470 1473 result = False
1471 1474 else:
1472 1475 result = True
1473 1476 Term.cout.write("\b"*37 + " "*37 + "\b"*37)
1474 1477 return result
1475 1478 else:
1476 1479 def page_more():
1477 1480 ans = raw_input('---Return to continue, q to quit--- ')
1478 1481 if ans.lower().startswith('q'):
1479 1482 return False
1480 1483 else:
1481 1484 return True
1482 1485
1483 1486 esc_re = re.compile(r"(\x1b[^m]+m)")
1484 1487
1485 1488 def page_dumb(strng,start=0,screen_lines=25):
1486 1489 """Very dumb 'pager' in Python, for when nothing else works.
1487 1490
1488 1491 Only moves forward, same interface as page(), except for pager_cmd and
1489 1492 mode."""
1490 1493
1491 1494 out_ln = strng.splitlines()[start:]
1492 1495 screens = chop(out_ln,screen_lines-1)
1493 1496 if len(screens) == 1:
1494 1497 print >>Term.cout, os.linesep.join(screens[0])
1495 1498 else:
1496 1499 last_escape = ""
1497 1500 for scr in screens[0:-1]:
1498 1501 hunk = os.linesep.join(scr)
1499 1502 print >>Term.cout, last_escape + hunk
1500 1503 if not page_more():
1501 1504 return
1502 1505 esc_list = esc_re.findall(hunk)
1503 1506 if len(esc_list) > 0:
1504 1507 last_escape = esc_list[-1]
1505 1508 print >>Term.cout, last_escape + os.linesep.join(screens[-1])
1506 1509
1507 1510 #----------------------------------------------------------------------------
1508 1511 def page(strng,start=0,screen_lines=0,pager_cmd = None):
1509 1512 """Print a string, piping through a pager after a certain length.
1510 1513
1511 1514 The screen_lines parameter specifies the number of *usable* lines of your
1512 1515 terminal screen (total lines minus lines you need to reserve to show other
1513 1516 information).
1514 1517
1515 1518 If you set screen_lines to a number <=0, page() will try to auto-determine
1516 1519 your screen size and will only use up to (screen_size+screen_lines) for
1517 1520 printing, paging after that. That is, if you want auto-detection but need
1518 1521 to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
1519 1522 auto-detection without any lines reserved simply use screen_lines = 0.
1520 1523
1521 1524 If a string won't fit in the allowed lines, it is sent through the
1522 1525 specified pager command. If none given, look for PAGER in the environment,
1523 1526 and ultimately default to less.
1524 1527
1525 1528 If no system pager works, the string is sent through a 'dumb pager'
1526 1529 written in python, very simplistic.
1527 1530 """
1528 1531
1529 1532
1530 1533 # first, try the hook
1531 1534 ip = IPython.ipapi.get()
1532 1535 if ip:
1533 1536 try:
1534 1537 ip.IP.hooks.show_in_pager(strng)
1535 1538 return
1536 1539 except IPython.ipapi.TryNext:
1537 1540 pass
1538 1541
1539 1542 # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
1540 1543 TERM = os.environ.get('TERM','dumb')
1541 1544 if TERM in ['dumb','emacs'] and os.name != 'nt':
1542 1545 print strng
1543 1546 return
1544 1547 # chop off the topmost part of the string we don't want to see
1545 1548 str_lines = strng.split(os.linesep)[start:]
1546 1549 str_toprint = os.linesep.join(str_lines)
1547 1550 num_newlines = len(str_lines)
1548 1551 len_str = len(str_toprint)
1549 1552
1550 1553 # Dumb heuristics to guesstimate number of on-screen lines the string
1551 1554 # takes. Very basic, but good enough for docstrings in reasonable
1552 1555 # terminals. If someone later feels like refining it, it's not hard.
1553 1556 numlines = max(num_newlines,int(len_str/80)+1)
1554 1557
1555 1558 if os.name == "nt":
1556 1559 screen_lines_def = get_console_size(defaulty=25)[1]
1557 1560 else:
1558 1561 screen_lines_def = 25 # default value if we can't auto-determine
1559 1562
1560 1563 # auto-determine screen size
1561 1564 if screen_lines <= 0:
1562 1565 if TERM=='xterm':
1563 1566 use_curses = USE_CURSES
1564 1567 else:
1565 1568 # curses causes problems on many terminals other than xterm.
1566 1569 use_curses = False
1567 1570 if use_curses:
1568 1571 # There is a bug in curses, where *sometimes* it fails to properly
1569 1572 # initialize, and then after the endwin() call is made, the
1570 1573 # terminal is left in an unusable state. Rather than trying to
1571 1574 # check everytime for this (by requesting and comparing termios
1572 1575 # flags each time), we just save the initial terminal state and
1573 1576 # unconditionally reset it every time. It's cheaper than making
1574 1577 # the checks.
1575 1578 term_flags = termios.tcgetattr(sys.stdout)
1576 1579 scr = curses.initscr()
1577 1580 screen_lines_real,screen_cols = scr.getmaxyx()
1578 1581 curses.endwin()
1579 1582 # Restore terminal state in case endwin() didn't.
1580 1583 termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
1581 1584 # Now we have what we needed: the screen size in rows/columns
1582 1585 screen_lines += screen_lines_real
1583 1586 #print '***Screen size:',screen_lines_real,'lines x',\
1584 1587 #screen_cols,'columns.' # dbg
1585 1588 else:
1586 1589 screen_lines += screen_lines_def
1587 1590
1588 1591 #print 'numlines',numlines,'screenlines',screen_lines # dbg
1589 1592 if numlines <= screen_lines :
1590 1593 #print '*** normal print' # dbg
1591 1594 print >>Term.cout, str_toprint
1592 1595 else:
1593 1596 # Try to open pager and default to internal one if that fails.
1594 1597 # All failure modes are tagged as 'retval=1', to match the return
1595 1598 # value of a failed system command. If any intermediate attempt
1596 1599 # sets retval to 1, at the end we resort to our own page_dumb() pager.
1597 1600 pager_cmd = get_pager_cmd(pager_cmd)
1598 1601 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
1599 1602 if os.name == 'nt':
1600 1603 if pager_cmd.startswith('type'):
1601 1604 # The default WinXP 'type' command is failing on complex strings.
1602 1605 retval = 1
1603 1606 else:
1604 1607 tmpname = tempfile.mktemp('.txt')
1605 1608 tmpfile = file(tmpname,'wt')
1606 1609 tmpfile.write(strng)
1607 1610 tmpfile.close()
1608 1611 cmd = "%s < %s" % (pager_cmd,tmpname)
1609 1612 if os.system(cmd):
1610 1613 retval = 1
1611 1614 else:
1612 1615 retval = None
1613 1616 os.remove(tmpname)
1614 1617 else:
1615 1618 try:
1616 1619 retval = None
1617 1620 # if I use popen4, things hang. No idea why.
1618 1621 #pager,shell_out = os.popen4(pager_cmd)
1619 1622 pager = os.popen(pager_cmd,'w')
1620 1623 pager.write(strng)
1621 1624 pager.close()
1622 1625 retval = pager.close() # success returns None
1623 1626 except IOError,msg: # broken pipe when user quits
1624 1627 if msg.args == (32,'Broken pipe'):
1625 1628 retval = None
1626 1629 else:
1627 1630 retval = 1
1628 1631 except OSError:
1629 1632 # Other strange problems, sometimes seen in Win2k/cygwin
1630 1633 retval = 1
1631 1634 if retval is not None:
1632 1635 page_dumb(strng,screen_lines=screen_lines)
1633 1636
1634 1637 #----------------------------------------------------------------------------
1635 1638 def page_file(fname,start = 0, pager_cmd = None):
1636 1639 """Page a file, using an optional pager command and starting line.
1637 1640 """
1638 1641
1639 1642 pager_cmd = get_pager_cmd(pager_cmd)
1640 1643 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
1641 1644
1642 1645 try:
1643 1646 if os.environ['TERM'] in ['emacs','dumb']:
1644 1647 raise EnvironmentError
1645 1648 xsys(pager_cmd + ' ' + fname)
1646 1649 except:
1647 1650 try:
1648 1651 if start > 0:
1649 1652 start -= 1
1650 1653 page(open(fname).read(),start)
1651 1654 except:
1652 1655 print 'Unable to show file',`fname`
1653 1656
1654 1657
1655 1658 #----------------------------------------------------------------------------
1656 1659 def snip_print(str,width = 75,print_full = 0,header = ''):
1657 1660 """Print a string snipping the midsection to fit in width.
1658 1661
1659 1662 print_full: mode control:
1660 1663 - 0: only snip long strings
1661 1664 - 1: send to page() directly.
1662 1665 - 2: snip long strings and ask for full length viewing with page()
1663 1666 Return 1 if snipping was necessary, 0 otherwise."""
1664 1667
1665 1668 if print_full == 1:
1666 1669 page(header+str)
1667 1670 return 0
1668 1671
1669 1672 print header,
1670 1673 if len(str) < width:
1671 1674 print str
1672 1675 snip = 0
1673 1676 else:
1674 1677 whalf = int((width -5)/2)
1675 1678 print str[:whalf] + ' <...> ' + str[-whalf:]
1676 1679 snip = 1
1677 1680 if snip and print_full == 2:
1678 1681 if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
1679 1682 page(str)
1680 1683 return snip
1681 1684
1682 1685 #****************************************************************************
1683 1686 # lists, dicts and structures
1684 1687
1685 1688 def belong(candidates,checklist):
1686 1689 """Check whether a list of items appear in a given list of options.
1687 1690
1688 1691 Returns a list of 1 and 0, one for each candidate given."""
1689 1692
1690 1693 return [x in checklist for x in candidates]
1691 1694
1692 1695 #----------------------------------------------------------------------------
1693 1696 def uniq_stable(elems):
1694 1697 """uniq_stable(elems) -> list
1695 1698
1696 1699 Return from an iterable, a list of all the unique elements in the input,
1697 1700 but maintaining the order in which they first appear.
1698 1701
1699 1702 A naive solution to this problem which just makes a dictionary with the
1700 1703 elements as keys fails to respect the stability condition, since
1701 1704 dictionaries are unsorted by nature.
1702 1705
1703 1706 Note: All elements in the input must be valid dictionary keys for this
1704 1707 routine to work, as it internally uses a dictionary for efficiency
1705 1708 reasons."""
1706 1709
1707 1710 unique = []
1708 1711 unique_dict = {}
1709 1712 for nn in elems:
1710 1713 if nn not in unique_dict:
1711 1714 unique.append(nn)
1712 1715 unique_dict[nn] = None
1713 1716 return unique
1714 1717
1715 1718 #----------------------------------------------------------------------------
1716 1719 class NLprinter:
1717 1720 """Print an arbitrarily nested list, indicating index numbers.
1718 1721
1719 1722 An instance of this class called nlprint is available and callable as a
1720 1723 function.
1721 1724
1722 1725 nlprint(list,indent=' ',sep=': ') -> prints indenting each level by 'indent'
1723 1726 and using 'sep' to separate the index from the value. """
1724 1727
1725 1728 def __init__(self):
1726 1729 self.depth = 0
1727 1730
1728 1731 def __call__(self,lst,pos='',**kw):
1729 1732 """Prints the nested list numbering levels."""
1730 1733 kw.setdefault('indent',' ')
1731 1734 kw.setdefault('sep',': ')
1732 1735 kw.setdefault('start',0)
1733 1736 kw.setdefault('stop',len(lst))
1734 1737 # we need to remove start and stop from kw so they don't propagate
1735 1738 # into a recursive call for a nested list.
1736 1739 start = kw['start']; del kw['start']
1737 1740 stop = kw['stop']; del kw['stop']
1738 1741 if self.depth == 0 and 'header' in kw.keys():
1739 1742 print kw['header']
1740 1743
1741 1744 for idx in range(start,stop):
1742 1745 elem = lst[idx]
1743 1746 if type(elem)==type([]):
1744 1747 self.depth += 1
1745 1748 self.__call__(elem,itpl('$pos$idx,'),**kw)
1746 1749 self.depth -= 1
1747 1750 else:
1748 1751 printpl(kw['indent']*self.depth+'$pos$idx$kw["sep"]$elem')
1749 1752
1750 1753 nlprint = NLprinter()
1751 1754 #----------------------------------------------------------------------------
1752 1755 def all_belong(candidates,checklist):
1753 1756 """Check whether a list of items ALL appear in a given list of options.
1754 1757
1755 1758 Returns a single 1 or 0 value."""
1756 1759
1757 1760 return 1-(0 in [x in checklist for x in candidates])
1758 1761
1759 1762 #----------------------------------------------------------------------------
1760 1763 def sort_compare(lst1,lst2,inplace = 1):
1761 1764 """Sort and compare two lists.
1762 1765
1763 1766 By default it does it in place, thus modifying the lists. Use inplace = 0
1764 1767 to avoid that (at the cost of temporary copy creation)."""
1765 1768 if not inplace:
1766 1769 lst1 = lst1[:]
1767 1770 lst2 = lst2[:]
1768 1771 lst1.sort(); lst2.sort()
1769 1772 return lst1 == lst2
1770 1773
1771 1774 #----------------------------------------------------------------------------
1772 1775 def mkdict(**kwargs):
1773 1776 """Return a dict from a keyword list.
1774 1777
1775 1778 It's just syntactic sugar for making ditcionary creation more convenient:
1776 1779 # the standard way
1777 1780 >>>data = { 'red' : 1, 'green' : 2, 'blue' : 3 }
1778 1781 # a cleaner way
1779 1782 >>>data = dict(red=1, green=2, blue=3)
1780 1783
1781 1784 If you need more than this, look at the Struct() class."""
1782 1785
1783 1786 return kwargs
1784 1787
1785 1788 #----------------------------------------------------------------------------
1786 1789 def list2dict(lst):
1787 1790 """Takes a list of (key,value) pairs and turns it into a dict."""
1788 1791
1789 1792 dic = {}
1790 1793 for k,v in lst: dic[k] = v
1791 1794 return dic
1792 1795
1793 1796 #----------------------------------------------------------------------------
1794 1797 def list2dict2(lst,default=''):
1795 1798 """Takes a list and turns it into a dict.
1796 1799 Much slower than list2dict, but more versatile. This version can take
1797 1800 lists with sublists of arbitrary length (including sclars)."""
1798 1801
1799 1802 dic = {}
1800 1803 for elem in lst:
1801 1804 if type(elem) in (types.ListType,types.TupleType):
1802 1805 size = len(elem)
1803 1806 if size == 0:
1804 1807 pass
1805 1808 elif size == 1:
1806 1809 dic[elem] = default
1807 1810 else:
1808 1811 k,v = elem[0], elem[1:]
1809 1812 if len(v) == 1: v = v[0]
1810 1813 dic[k] = v
1811 1814 else:
1812 1815 dic[elem] = default
1813 1816 return dic
1814 1817
1815 1818 #----------------------------------------------------------------------------
1816 1819 def flatten(seq):
1817 1820 """Flatten a list of lists (NOT recursive, only works for 2d lists)."""
1818 1821
1819 1822 return [x for subseq in seq for x in subseq]
1820 1823
1821 1824 #----------------------------------------------------------------------------
1822 1825 def get_slice(seq,start=0,stop=None,step=1):
1823 1826 """Get a slice of a sequence with variable step. Specify start,stop,step."""
1824 1827 if stop == None:
1825 1828 stop = len(seq)
1826 1829 item = lambda i: seq[i]
1827 1830 return map(item,xrange(start,stop,step))
1828 1831
1829 1832 #----------------------------------------------------------------------------
1830 1833 def chop(seq,size):
1831 1834 """Chop a sequence into chunks of the given size."""
1832 1835 chunk = lambda i: seq[i:i+size]
1833 1836 return map(chunk,xrange(0,len(seq),size))
1834 1837
1835 1838 #----------------------------------------------------------------------------
1836 1839 # with is a keyword as of python 2.5, so this function is renamed to withobj
1837 1840 # from its old 'with' name.
1838 1841 def with_obj(object, **args):
1839 1842 """Set multiple attributes for an object, similar to Pascal's with.
1840 1843
1841 1844 Example:
1842 1845 with_obj(jim,
1843 1846 born = 1960,
1844 1847 haircolour = 'Brown',
1845 1848 eyecolour = 'Green')
1846 1849
1847 1850 Credit: Greg Ewing, in
1848 1851 http://mail.python.org/pipermail/python-list/2001-May/040703.html.
1849 1852
1850 1853 NOTE: up until IPython 0.7.2, this was called simply 'with', but 'with'
1851 1854 has become a keyword for Python 2.5, so we had to rename it."""
1852 1855
1853 1856 object.__dict__.update(args)
1854 1857
1855 1858 #----------------------------------------------------------------------------
1856 1859 def setattr_list(obj,alist,nspace = None):
1857 1860 """Set a list of attributes for an object taken from a namespace.
1858 1861
1859 1862 setattr_list(obj,alist,nspace) -> sets in obj all the attributes listed in
1860 1863 alist with their values taken from nspace, which must be a dict (something
1861 1864 like locals() will often do) If nspace isn't given, locals() of the
1862 1865 *caller* is used, so in most cases you can omit it.
1863 1866
1864 1867 Note that alist can be given as a string, which will be automatically
1865 1868 split into a list on whitespace. If given as a list, it must be a list of
1866 1869 *strings* (the variable names themselves), not of variables."""
1867 1870
1868 1871 # this grabs the local variables from the *previous* call frame -- that is
1869 1872 # the locals from the function that called setattr_list().
1870 1873 # - snipped from weave.inline()
1871 1874 if nspace is None:
1872 1875 call_frame = sys._getframe().f_back
1873 1876 nspace = call_frame.f_locals
1874 1877
1875 1878 if type(alist) in StringTypes:
1876 1879 alist = alist.split()
1877 1880 for attr in alist:
1878 1881 val = eval(attr,nspace)
1879 1882 setattr(obj,attr,val)
1880 1883
1881 1884 #----------------------------------------------------------------------------
1882 1885 def getattr_list(obj,alist,*args):
1883 1886 """getattr_list(obj,alist[, default]) -> attribute list.
1884 1887
1885 1888 Get a list of named attributes for an object. When a default argument is
1886 1889 given, it is returned when the attribute doesn't exist; without it, an
1887 1890 exception is raised in that case.
1888 1891
1889 1892 Note that alist can be given as a string, which will be automatically
1890 1893 split into a list on whitespace. If given as a list, it must be a list of
1891 1894 *strings* (the variable names themselves), not of variables."""
1892 1895
1893 1896 if type(alist) in StringTypes:
1894 1897 alist = alist.split()
1895 1898 if args:
1896 1899 if len(args)==1:
1897 1900 default = args[0]
1898 1901 return map(lambda attr: getattr(obj,attr,default),alist)
1899 1902 else:
1900 1903 raise ValueError,'getattr_list() takes only one optional argument'
1901 1904 else:
1902 1905 return map(lambda attr: getattr(obj,attr),alist)
1903 1906
1904 1907 #----------------------------------------------------------------------------
1905 1908 def map_method(method,object_list,*argseq,**kw):
1906 1909 """map_method(method,object_list,*args,**kw) -> list
1907 1910
1908 1911 Return a list of the results of applying the methods to the items of the
1909 1912 argument sequence(s). If more than one sequence is given, the method is
1910 1913 called with an argument list consisting of the corresponding item of each
1911 1914 sequence. All sequences must be of the same length.
1912 1915
1913 1916 Keyword arguments are passed verbatim to all objects called.
1914 1917
1915 1918 This is Python code, so it's not nearly as fast as the builtin map()."""
1916 1919
1917 1920 out_list = []
1918 1921 idx = 0
1919 1922 for object in object_list:
1920 1923 try:
1921 1924 handler = getattr(object, method)
1922 1925 except AttributeError:
1923 1926 out_list.append(None)
1924 1927 else:
1925 1928 if argseq:
1926 1929 args = map(lambda lst:lst[idx],argseq)
1927 1930 #print 'ob',object,'hand',handler,'ar',args # dbg
1928 1931 out_list.append(handler(args,**kw))
1929 1932 else:
1930 1933 out_list.append(handler(**kw))
1931 1934 idx += 1
1932 1935 return out_list
1933 1936
1934 1937 #----------------------------------------------------------------------------
1935 1938 def get_class_members(cls):
1936 1939 ret = dir(cls)
1937 1940 if hasattr(cls,'__bases__'):
1938 1941 for base in cls.__bases__:
1939 1942 ret.extend(get_class_members(base))
1940 1943 return ret
1941 1944
1942 1945 #----------------------------------------------------------------------------
1943 1946 def dir2(obj):
1944 1947 """dir2(obj) -> list of strings
1945 1948
1946 1949 Extended version of the Python builtin dir(), which does a few extra
1947 1950 checks, and supports common objects with unusual internals that confuse
1948 1951 dir(), such as Traits and PyCrust.
1949 1952
1950 1953 This version is guaranteed to return only a list of true strings, whereas
1951 1954 dir() returns anything that objects inject into themselves, even if they
1952 1955 are later not really valid for attribute access (many extension libraries
1953 1956 have such bugs).
1954 1957 """
1955 1958
1956 1959 # Start building the attribute list via dir(), and then complete it
1957 1960 # with a few extra special-purpose calls.
1958 1961 words = dir(obj)
1959 1962
1960 1963 if hasattr(obj,'__class__'):
1961 1964 words.append('__class__')
1962 1965 words.extend(get_class_members(obj.__class__))
1963 1966 #if '__base__' in words: 1/0
1964 1967
1965 1968 # Some libraries (such as traits) may introduce duplicates, we want to
1966 1969 # track and clean this up if it happens
1967 1970 may_have_dupes = False
1968 1971
1969 1972 # this is the 'dir' function for objects with Enthought's traits
1970 1973 if hasattr(obj, 'trait_names'):
1971 1974 try:
1972 1975 words.extend(obj.trait_names())
1973 1976 may_have_dupes = True
1974 1977 except TypeError:
1975 1978 # This will happen if `obj` is a class and not an instance.
1976 1979 pass
1977 1980
1978 1981 # Support for PyCrust-style _getAttributeNames magic method.
1979 1982 if hasattr(obj, '_getAttributeNames'):
1980 1983 try:
1981 1984 words.extend(obj._getAttributeNames())
1982 1985 may_have_dupes = True
1983 1986 except TypeError:
1984 1987 # `obj` is a class and not an instance. Ignore
1985 1988 # this error.
1986 1989 pass
1987 1990
1988 1991 if may_have_dupes:
1989 1992 # eliminate possible duplicates, as some traits may also
1990 1993 # appear as normal attributes in the dir() call.
1991 1994 words = list(set(words))
1992 1995 words.sort()
1993 1996
1994 1997 # filter out non-string attributes which may be stuffed by dir() calls
1995 1998 # and poor coding in third-party modules
1996 1999 return [w for w in words if isinstance(w, basestring)]
1997 2000
1998 2001 #----------------------------------------------------------------------------
1999 2002 def import_fail_info(mod_name,fns=None):
2000 2003 """Inform load failure for a module."""
2001 2004
2002 2005 if fns == None:
2003 2006 warn("Loading of %s failed.\n" % (mod_name,))
2004 2007 else:
2005 2008 warn("Loading of %s from %s failed.\n" % (fns,mod_name))
2006 2009
2007 2010 #----------------------------------------------------------------------------
2008 2011 # Proposed popitem() extension, written as a method
2009 2012
2010 2013
2011 2014 class NotGiven: pass
2012 2015
2013 2016 def popkey(dct,key,default=NotGiven):
2014 2017 """Return dct[key] and delete dct[key].
2015 2018
2016 2019 If default is given, return it if dct[key] doesn't exist, otherwise raise
2017 2020 KeyError. """
2018 2021
2019 2022 try:
2020 2023 val = dct[key]
2021 2024 except KeyError:
2022 2025 if default is NotGiven:
2023 2026 raise
2024 2027 else:
2025 2028 return default
2026 2029 else:
2027 2030 del dct[key]
2028 2031 return val
2029 2032
2030 2033 def wrap_deprecated(func, suggest = '<nothing>'):
2031 2034 def newFunc(*args, **kwargs):
2032 2035 warnings.warn("Call to deprecated function %s, use %s instead" %
2033 2036 ( func.__name__, suggest),
2034 2037 category=DeprecationWarning,
2035 2038 stacklevel = 2)
2036 2039 return func(*args, **kwargs)
2037 2040 return newFunc
2038 2041
2039 2042 #*************************** end of file <genutils.py> **********************
2040 2043
@@ -1,2683 +1,2686 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 IPython -- An enhanced Interactive Python
4 4
5 5 Requires Python 2.3 or newer.
6 6
7 7 This file contains all the classes and helper functions specific to IPython.
8 8
9 9 """
10 10
11 11 #*****************************************************************************
12 12 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
13 13 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
14 14 #
15 15 # Distributed under the terms of the BSD License. The full license is in
16 16 # the file COPYING, distributed as part of this software.
17 17 #
18 18 # Note: this code originally subclassed code.InteractiveConsole from the
19 19 # Python standard library. Over time, all of that class has been copied
20 20 # verbatim here for modifications which could not be accomplished by
21 21 # subclassing. At this point, there are no dependencies at all on the code
22 22 # module anymore (it is not even imported). The Python License (sec. 2)
23 23 # allows for this, but it's always nice to acknowledge credit where credit is
24 24 # due.
25 25 #*****************************************************************************
26 26
27 27 #****************************************************************************
28 28 # Modules and globals
29 29
30 30 from IPython import Release
31 31 __author__ = '%s <%s>\n%s <%s>' % \
32 32 ( Release.authors['Janko'] + Release.authors['Fernando'] )
33 33 __license__ = Release.license
34 34 __version__ = Release.version
35 35
36 36 # Python standard modules
37 37 import __main__
38 38 import __builtin__
39 39 import StringIO
40 40 import bdb
41 41 import cPickle as pickle
42 42 import codeop
43 43 import exceptions
44 44 import glob
45 45 import inspect
46 46 import keyword
47 47 import new
48 48 import os
49 49 import pydoc
50 50 import re
51 51 import shutil
52 52 import string
53 53 import sys
54 54 import tempfile
55 55 import traceback
56 56 import types
57 57 import warnings
58 58 warnings.filterwarnings('ignore', r'.*sets module*')
59 59 from sets import Set
60 60 from pprint import pprint, pformat
61 61
62 62 # IPython's own modules
63 63 #import IPython
64 64 from IPython import Debugger,OInspect,PyColorize,ultraTB
65 65 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
66 66 from IPython.Extensions import pickleshare
67 67 from IPython.FakeModule import FakeModule
68 68 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
69 69 from IPython.Logger import Logger
70 70 from IPython.Magic import Magic
71 71 from IPython.Prompts import CachedOutput
72 72 from IPython.ipstruct import Struct
73 73 from IPython.background_jobs import BackgroundJobManager
74 74 from IPython.usage import cmd_line_usage,interactive_usage
75 75 from IPython.genutils import *
76 76 from IPython.strdispatch import StrDispatch
77 77 import IPython.ipapi
78 78 import IPython.history
79 79 import IPython.prefilter as prefilter
80 80 import IPython.shadowns
81 81 # Globals
82 82
83 83 # store the builtin raw_input globally, and use this always, in case user code
84 84 # overwrites it (like wx.py.PyShell does)
85 85 raw_input_original = raw_input
86 86
87 87 # compiled regexps for autoindent management
88 88 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
89 89
90 90
91 91 #****************************************************************************
92 92 # Some utility function definitions
93 93
94 94 ini_spaces_re = re.compile(r'^(\s+)')
95 95
96 96 def num_ini_spaces(strng):
97 97 """Return the number of initial spaces in a string"""
98 98
99 99 ini_spaces = ini_spaces_re.match(strng)
100 100 if ini_spaces:
101 101 return ini_spaces.end()
102 102 else:
103 103 return 0
104 104
105 105 def softspace(file, newvalue):
106 106 """Copied from code.py, to remove the dependency"""
107 107
108 108 oldvalue = 0
109 109 try:
110 110 oldvalue = file.softspace
111 111 except AttributeError:
112 112 pass
113 113 try:
114 114 file.softspace = newvalue
115 115 except (AttributeError, TypeError):
116 116 # "attribute-less object" or "read-only attributes"
117 117 pass
118 118 return oldvalue
119 119
120 120
121 121 #****************************************************************************
122 122 # Local use exceptions
123 123 class SpaceInInput(exceptions.Exception): pass
124 124
125 125
126 126 #****************************************************************************
127 127 # Local use classes
128 128 class Bunch: pass
129 129
130 130 class Undefined: pass
131 131
132 132 class Quitter(object):
133 133 """Simple class to handle exit, similar to Python 2.5's.
134 134
135 135 It handles exiting in an ipython-safe manner, which the one in Python 2.5
136 136 doesn't do (obviously, since it doesn't know about ipython)."""
137 137
138 138 def __init__(self,shell,name):
139 139 self.shell = shell
140 140 self.name = name
141 141
142 142 def __repr__(self):
143 143 return 'Type %s() to exit.' % self.name
144 144 __str__ = __repr__
145 145
146 146 def __call__(self):
147 147 self.shell.exit()
148 148
149 149 class InputList(list):
150 150 """Class to store user input.
151 151
152 152 It's basically a list, but slices return a string instead of a list, thus
153 153 allowing things like (assuming 'In' is an instance):
154 154
155 155 exec In[4:7]
156 156
157 157 or
158 158
159 159 exec In[5:9] + In[14] + In[21:25]"""
160 160
161 161 def __getslice__(self,i,j):
162 162 return ''.join(list.__getslice__(self,i,j))
163 163
164 164 class SyntaxTB(ultraTB.ListTB):
165 165 """Extension which holds some state: the last exception value"""
166 166
167 167 def __init__(self,color_scheme = 'NoColor'):
168 168 ultraTB.ListTB.__init__(self,color_scheme)
169 169 self.last_syntax_error = None
170 170
171 171 def __call__(self, etype, value, elist):
172 172 self.last_syntax_error = value
173 173 ultraTB.ListTB.__call__(self,etype,value,elist)
174 174
175 175 def clear_err_state(self):
176 176 """Return the current error state and clear it"""
177 177 e = self.last_syntax_error
178 178 self.last_syntax_error = None
179 179 return e
180 180
181 181 #****************************************************************************
182 182 # Main IPython class
183 183
184 184 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
185 185 # until a full rewrite is made. I've cleaned all cross-class uses of
186 186 # attributes and methods, but too much user code out there relies on the
187 187 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
188 188 #
189 189 # But at least now, all the pieces have been separated and we could, in
190 190 # principle, stop using the mixin. This will ease the transition to the
191 191 # chainsaw branch.
192 192
193 193 # For reference, the following is the list of 'self.foo' uses in the Magic
194 194 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
195 195 # class, to prevent clashes.
196 196
197 197 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
198 198 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
199 199 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
200 200 # 'self.value']
201 201
202 202 class InteractiveShell(object,Magic):
203 203 """An enhanced console for Python."""
204 204
205 205 # class attribute to indicate whether the class supports threads or not.
206 206 # Subclasses with thread support should override this as needed.
207 207 isthreaded = False
208 208
209 209 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
210 210 user_ns = None,user_global_ns=None,banner2='',
211 211 custom_exceptions=((),None),embedded=False):
212 212
213 213 # log system
214 214 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
215 215
216 216 # some minimal strict typechecks. For some core data structures, I
217 217 # want actual basic python types, not just anything that looks like
218 218 # one. This is especially true for namespaces.
219 219 for ns in (user_ns,user_global_ns):
220 220 if ns is not None and type(ns) != types.DictType:
221 221 raise TypeError,'namespace must be a dictionary'
222 222 # Job manager (for jobs run as background threads)
223 223 self.jobs = BackgroundJobManager()
224 224
225 225 # Store the actual shell's name
226 226 self.name = name
227 227 self.more = False
228 228
229 229 # We need to know whether the instance is meant for embedding, since
230 230 # global/local namespaces need to be handled differently in that case
231 231 self.embedded = embedded
232 232 if embedded:
233 233 # Control variable so users can, from within the embedded instance,
234 234 # permanently deactivate it.
235 235 self.embedded_active = True
236 236
237 237 # command compiler
238 238 self.compile = codeop.CommandCompiler()
239 239
240 240 # User input buffer
241 241 self.buffer = []
242 242
243 243 # Default name given in compilation of code
244 244 self.filename = '<ipython console>'
245 245
246 246 # Install our own quitter instead of the builtins. For python2.3-2.4,
247 247 # this brings in behavior like 2.5, and for 2.5 it's identical.
248 248 __builtin__.exit = Quitter(self,'exit')
249 249 __builtin__.quit = Quitter(self,'quit')
250 250
251 251 # Make an empty namespace, which extension writers can rely on both
252 252 # existing and NEVER being used by ipython itself. This gives them a
253 253 # convenient location for storing additional information and state
254 254 # their extensions may require, without fear of collisions with other
255 255 # ipython names that may develop later.
256 256 self.meta = Struct()
257 257
258 258 # Create the namespace where the user will operate. user_ns is
259 259 # normally the only one used, and it is passed to the exec calls as
260 260 # the locals argument. But we do carry a user_global_ns namespace
261 261 # given as the exec 'globals' argument, This is useful in embedding
262 262 # situations where the ipython shell opens in a context where the
263 263 # distinction between locals and globals is meaningful.
264 264
265 265 # FIXME. For some strange reason, __builtins__ is showing up at user
266 266 # level as a dict instead of a module. This is a manual fix, but I
267 267 # should really track down where the problem is coming from. Alex
268 268 # Schmolck reported this problem first.
269 269
270 270 # A useful post by Alex Martelli on this topic:
271 271 # Re: inconsistent value from __builtins__
272 272 # Von: Alex Martelli <aleaxit@yahoo.com>
273 273 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
274 274 # Gruppen: comp.lang.python
275 275
276 276 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
277 277 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
278 278 # > <type 'dict'>
279 279 # > >>> print type(__builtins__)
280 280 # > <type 'module'>
281 281 # > Is this difference in return value intentional?
282 282
283 283 # Well, it's documented that '__builtins__' can be either a dictionary
284 284 # or a module, and it's been that way for a long time. Whether it's
285 285 # intentional (or sensible), I don't know. In any case, the idea is
286 286 # that if you need to access the built-in namespace directly, you
287 287 # should start with "import __builtin__" (note, no 's') which will
288 288 # definitely give you a module. Yeah, it's somewhat confusing:-(.
289 289
290 290 # These routines return properly built dicts as needed by the rest of
291 291 # the code, and can also be used by extension writers to generate
292 292 # properly initialized namespaces.
293 293 user_ns = IPython.ipapi.make_user_ns(user_ns)
294 294 user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
295 295
296 296 # Assign namespaces
297 297 # This is the namespace where all normal user variables live
298 298 self.user_ns = user_ns
299 299 # Embedded instances require a separate namespace for globals.
300 300 # Normally this one is unused by non-embedded instances.
301 301 self.user_global_ns = user_global_ns
302 302 # A namespace to keep track of internal data structures to prevent
303 303 # them from cluttering user-visible stuff. Will be updated later
304 304 self.internal_ns = {}
305 305
306 306 # Namespace of system aliases. Each entry in the alias
307 307 # table must be a 2-tuple of the form (N,name), where N is the number
308 308 # of positional arguments of the alias.
309 309 self.alias_table = {}
310 310
311 311 # A table holding all the namespaces IPython deals with, so that
312 312 # introspection facilities can search easily.
313 313 self.ns_table = {'user':user_ns,
314 314 'user_global':user_global_ns,
315 315 'alias':self.alias_table,
316 316 'internal':self.internal_ns,
317 317 'builtin':__builtin__.__dict__
318 318 }
319 319 # The user namespace MUST have a pointer to the shell itself.
320 320 self.user_ns[name] = self
321 321
322 322 # We need to insert into sys.modules something that looks like a
323 323 # module but which accesses the IPython namespace, for shelve and
324 324 # pickle to work interactively. Normally they rely on getting
325 325 # everything out of __main__, but for embedding purposes each IPython
326 326 # instance has its own private namespace, so we can't go shoving
327 327 # everything into __main__.
328 328
329 329 # note, however, that we should only do this for non-embedded
330 330 # ipythons, which really mimic the __main__.__dict__ with their own
331 331 # namespace. Embedded instances, on the other hand, should not do
332 332 # this because they need to manage the user local/global namespaces
333 333 # only, but they live within a 'normal' __main__ (meaning, they
334 334 # shouldn't overtake the execution environment of the script they're
335 335 # embedded in).
336 336
337 337 if not embedded:
338 338 try:
339 339 main_name = self.user_ns['__name__']
340 340 except KeyError:
341 341 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
342 342 else:
343 343 #print "pickle hack in place" # dbg
344 344 #print 'main_name:',main_name # dbg
345 345 sys.modules[main_name] = FakeModule(self.user_ns)
346 346
347 347 # Now that FakeModule produces a real module, we've run into a nasty
348 348 # problem: after script execution (via %run), the module where the user
349 349 # code ran is deleted. Now that this object is a true module (needed
350 350 # so docetst and other tools work correctly), the Python module
351 351 # teardown mechanism runs over it, and sets to None every variable
352 352 # present in that module. This means that later calls to functions
353 353 # defined in the script (which have become interactively visible after
354 354 # script exit) fail, because they hold references to objects that have
355 355 # become overwritten into None. The only solution I see right now is
356 356 # to protect every FakeModule used by %run by holding an internal
357 357 # reference to it. This private list will be used for that. The
358 358 # %reset command will flush it as well.
359 359 self._user_main_modules = []
360 360
361 361 # List of input with multi-line handling.
362 362 # Fill its zero entry, user counter starts at 1
363 363 self.input_hist = InputList(['\n'])
364 364 # This one will hold the 'raw' input history, without any
365 365 # pre-processing. This will allow users to retrieve the input just as
366 366 # it was exactly typed in by the user, with %hist -r.
367 367 self.input_hist_raw = InputList(['\n'])
368 368
369 369 # list of visited directories
370 370 try:
371 371 self.dir_hist = [os.getcwd()]
372 372 except OSError:
373 373 self.dir_hist = []
374 374
375 375 # dict of output history
376 376 self.output_hist = {}
377 377
378 378 # Get system encoding at startup time. Certain terminals (like Emacs
379 379 # under Win32 have it set to None, and we need to have a known valid
380 380 # encoding to use in the raw_input() method
381 381 try:
382 382 self.stdin_encoding = sys.stdin.encoding or 'ascii'
383 383 except AttributeError:
384 384 self.stdin_encoding = 'ascii'
385 385
386 386 # dict of things NOT to alias (keywords, builtins and some magics)
387 387 no_alias = {}
388 388 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
389 389 for key in keyword.kwlist + no_alias_magics:
390 390 no_alias[key] = 1
391 391 no_alias.update(__builtin__.__dict__)
392 392 self.no_alias = no_alias
393 393
394 394 # make global variables for user access to these
395 395 self.user_ns['_ih'] = self.input_hist
396 396 self.user_ns['_oh'] = self.output_hist
397 397 self.user_ns['_dh'] = self.dir_hist
398 398
399 399 # user aliases to input and output histories
400 400 self.user_ns['In'] = self.input_hist
401 401 self.user_ns['Out'] = self.output_hist
402 402
403 403 self.user_ns['_sh'] = IPython.shadowns
404 404 # Object variable to store code object waiting execution. This is
405 405 # used mainly by the multithreaded shells, but it can come in handy in
406 406 # other situations. No need to use a Queue here, since it's a single
407 407 # item which gets cleared once run.
408 408 self.code_to_run = None
409 409
410 410 # escapes for automatic behavior on the command line
411 411 self.ESC_SHELL = '!'
412 412 self.ESC_SH_CAP = '!!'
413 413 self.ESC_HELP = '?'
414 414 self.ESC_MAGIC = '%'
415 415 self.ESC_QUOTE = ','
416 416 self.ESC_QUOTE2 = ';'
417 417 self.ESC_PAREN = '/'
418 418
419 419 # And their associated handlers
420 420 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
421 421 self.ESC_QUOTE : self.handle_auto,
422 422 self.ESC_QUOTE2 : self.handle_auto,
423 423 self.ESC_MAGIC : self.handle_magic,
424 424 self.ESC_HELP : self.handle_help,
425 425 self.ESC_SHELL : self.handle_shell_escape,
426 426 self.ESC_SH_CAP : self.handle_shell_escape,
427 427 }
428 428
429 429 # class initializations
430 430 Magic.__init__(self,self)
431 431
432 432 # Python source parser/formatter for syntax highlighting
433 433 pyformat = PyColorize.Parser().format
434 434 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
435 435
436 436 # hooks holds pointers used for user-side customizations
437 437 self.hooks = Struct()
438 438
439 439 self.strdispatchers = {}
440 440
441 441 # Set all default hooks, defined in the IPython.hooks module.
442 442 hooks = IPython.hooks
443 443 for hook_name in hooks.__all__:
444 444 # default hooks have priority 100, i.e. low; user hooks should have
445 445 # 0-100 priority
446 446 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
447 447 #print "bound hook",hook_name
448 448
449 449 # Flag to mark unconditional exit
450 450 self.exit_now = False
451 451
452 452 self.usage_min = """\
453 453 An enhanced console for Python.
454 454 Some of its features are:
455 455 - Readline support if the readline library is present.
456 456 - Tab completion in the local namespace.
457 457 - Logging of input, see command-line options.
458 458 - System shell escape via ! , eg !ls.
459 459 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
460 460 - Keeps track of locally defined variables via %who, %whos.
461 461 - Show object information with a ? eg ?x or x? (use ?? for more info).
462 462 """
463 463 if usage: self.usage = usage
464 464 else: self.usage = self.usage_min
465 465
466 466 # Storage
467 467 self.rc = rc # This will hold all configuration information
468 468 self.pager = 'less'
469 469 # temporary files used for various purposes. Deleted at exit.
470 470 self.tempfiles = []
471 471
472 472 # Keep track of readline usage (later set by init_readline)
473 473 self.has_readline = False
474 474
475 475 # template for logfile headers. It gets resolved at runtime by the
476 476 # logstart method.
477 477 self.loghead_tpl = \
478 478 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
479 479 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
480 480 #log# opts = %s
481 481 #log# args = %s
482 482 #log# It is safe to make manual edits below here.
483 483 #log#-----------------------------------------------------------------------
484 484 """
485 485 # for pushd/popd management
486 486 try:
487 487 self.home_dir = get_home_dir()
488 488 except HomeDirError,msg:
489 489 fatal(msg)
490 490
491 491 self.dir_stack = []
492 492
493 493 # Functions to call the underlying shell.
494 494
495 495 # The first is similar to os.system, but it doesn't return a value,
496 496 # and it allows interpolation of variables in the user's namespace.
497 497 self.system = lambda cmd: \
498 498 self.hooks.shell_hook(self.var_expand(cmd,depth=2))
499 499
500 500 # These are for getoutput and getoutputerror:
501 501 self.getoutput = lambda cmd: \
502 502 getoutput(self.var_expand(cmd,depth=2),
503 503 header=self.rc.system_header,
504 504 verbose=self.rc.system_verbose)
505 505
506 506 self.getoutputerror = lambda cmd: \
507 507 getoutputerror(self.var_expand(cmd,depth=2),
508 508 header=self.rc.system_header,
509 509 verbose=self.rc.system_verbose)
510 510
511 511
512 512 # keep track of where we started running (mainly for crash post-mortem)
513 513 self.starting_dir = os.getcwd()
514 514
515 515 # Various switches which can be set
516 516 self.CACHELENGTH = 5000 # this is cheap, it's just text
517 517 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
518 518 self.banner2 = banner2
519 519
520 520 # TraceBack handlers:
521 521
522 522 # Syntax error handler.
523 523 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
524 524
525 525 # The interactive one is initialized with an offset, meaning we always
526 526 # want to remove the topmost item in the traceback, which is our own
527 527 # internal code. Valid modes: ['Plain','Context','Verbose']
528 528 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
529 529 color_scheme='NoColor',
530 530 tb_offset = 1)
531 531
532 532 # IPython itself shouldn't crash. This will produce a detailed
533 533 # post-mortem if it does. But we only install the crash handler for
534 534 # non-threaded shells, the threaded ones use a normal verbose reporter
535 535 # and lose the crash handler. This is because exceptions in the main
536 536 # thread (such as in GUI code) propagate directly to sys.excepthook,
537 537 # and there's no point in printing crash dumps for every user exception.
538 538 if self.isthreaded:
539 539 ipCrashHandler = ultraTB.FormattedTB()
540 540 else:
541 541 from IPython import CrashHandler
542 542 ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
543 543 self.set_crash_handler(ipCrashHandler)
544 544
545 545 # and add any custom exception handlers the user may have specified
546 546 self.set_custom_exc(*custom_exceptions)
547 547
548 548 # indentation management
549 549 self.autoindent = False
550 550 self.indent_current_nsp = 0
551 551
552 552 # Make some aliases automatically
553 553 # Prepare list of shell aliases to auto-define
554 554 if os.name == 'posix':
555 555 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
556 556 'mv mv -i','rm rm -i','cp cp -i',
557 557 'cat cat','less less','clear clear',
558 558 # a better ls
559 559 'ls ls -F',
560 560 # long ls
561 561 'll ls -lF')
562 562 # Extra ls aliases with color, which need special treatment on BSD
563 563 # variants
564 564 ls_extra = ( # color ls
565 565 'lc ls -F -o --color',
566 566 # ls normal files only
567 567 'lf ls -F -o --color %l | grep ^-',
568 568 # ls symbolic links
569 569 'lk ls -F -o --color %l | grep ^l',
570 570 # directories or links to directories,
571 571 'ldir ls -F -o --color %l | grep /$',
572 572 # things which are executable
573 573 'lx ls -F -o --color %l | grep ^-..x',
574 574 )
575 575 # The BSDs don't ship GNU ls, so they don't understand the
576 576 # --color switch out of the box
577 577 if 'bsd' in sys.platform:
578 578 ls_extra = ( # ls normal files only
579 579 'lf ls -lF | grep ^-',
580 580 # ls symbolic links
581 581 'lk ls -lF | grep ^l',
582 582 # directories or links to directories,
583 583 'ldir ls -lF | grep /$',
584 584 # things which are executable
585 585 'lx ls -lF | grep ^-..x',
586 586 )
587 587 auto_alias = auto_alias + ls_extra
588 588 elif os.name in ['nt','dos']:
589 589 auto_alias = ('ls dir /on',
590 590 'ddir dir /ad /on', 'ldir dir /ad /on',
591 591 'mkdir mkdir','rmdir rmdir','echo echo',
592 592 'ren ren','cls cls','copy copy')
593 593 else:
594 594 auto_alias = ()
595 595 self.auto_alias = [s.split(None,1) for s in auto_alias]
596 596
597 597
598 598 # Produce a public API instance
599 599 self.api = IPython.ipapi.IPApi(self)
600 600
601 601 # Call the actual (public) initializer
602 602 self.init_auto_alias()
603 603
604 604 # track which builtins we add, so we can clean up later
605 605 self.builtins_added = {}
606 606 # This method will add the necessary builtins for operation, but
607 607 # tracking what it did via the builtins_added dict.
608 608
609 609 #TODO: remove this, redundant
610 610 self.add_builtins()
611 611
612 612
613 613
614 614
615 615 # end __init__
616 616
617 617 def var_expand(self,cmd,depth=0):
618 618 """Expand python variables in a string.
619 619
620 620 The depth argument indicates how many frames above the caller should
621 621 be walked to look for the local namespace where to expand variables.
622 622
623 623 The global namespace for expansion is always the user's interactive
624 624 namespace.
625 625 """
626 626
627 627 return str(ItplNS(cmd,
628 628 self.user_ns, # globals
629 629 # Skip our own frame in searching for locals:
630 630 sys._getframe(depth+1).f_locals # locals
631 631 ))
632 632
633 633 def pre_config_initialization(self):
634 634 """Pre-configuration init method
635 635
636 636 This is called before the configuration files are processed to
637 637 prepare the services the config files might need.
638 638
639 639 self.rc already has reasonable default values at this point.
640 640 """
641 641 rc = self.rc
642 642 try:
643 643 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
644 644 except exceptions.UnicodeDecodeError:
645 645 print "Your ipythondir can't be decoded to unicode!"
646 646 print "Please set HOME environment variable to something that"
647 647 print r"only has ASCII characters, e.g. c:\home"
648 648 print "Now it is",rc.ipythondir
649 649 sys.exit()
650 650 self.shadowhist = IPython.history.ShadowHist(self.db)
651 651
652 652
653 653 def post_config_initialization(self):
654 654 """Post configuration init method
655 655
656 656 This is called after the configuration files have been processed to
657 657 'finalize' the initialization."""
658 658
659 659 rc = self.rc
660 660
661 661 # Object inspector
662 662 self.inspector = OInspect.Inspector(OInspect.InspectColors,
663 663 PyColorize.ANSICodeColors,
664 664 'NoColor',
665 665 rc.object_info_string_level)
666 666
667 667 self.rl_next_input = None
668 668 self.rl_do_indent = False
669 669 # Load readline proper
670 670 if rc.readline:
671 671 self.init_readline()
672 672
673 673
674 674 # local shortcut, this is used a LOT
675 675 self.log = self.logger.log
676 676
677 677 # Initialize cache, set in/out prompts and printing system
678 678 self.outputcache = CachedOutput(self,
679 679 rc.cache_size,
680 680 rc.pprint,
681 681 input_sep = rc.separate_in,
682 682 output_sep = rc.separate_out,
683 683 output_sep2 = rc.separate_out2,
684 684 ps1 = rc.prompt_in1,
685 685 ps2 = rc.prompt_in2,
686 686 ps_out = rc.prompt_out,
687 687 pad_left = rc.prompts_pad_left)
688 688
689 689 # user may have over-ridden the default print hook:
690 690 try:
691 691 self.outputcache.__class__.display = self.hooks.display
692 692 except AttributeError:
693 693 pass
694 694
695 695 # I don't like assigning globally to sys, because it means when
696 696 # embedding instances, each embedded instance overrides the previous
697 697 # choice. But sys.displayhook seems to be called internally by exec,
698 698 # so I don't see a way around it. We first save the original and then
699 699 # overwrite it.
700 700 self.sys_displayhook = sys.displayhook
701 701 sys.displayhook = self.outputcache
702 702
703 703 # Do a proper resetting of doctest, including the necessary displayhook
704 704 # monkeypatching
705 doctest_reload()
705 try:
706 doctest_reload()
707 except ImportError:
708 warn("doctest module does not exist.")
706 709
707 710 # Set user colors (don't do it in the constructor above so that it
708 711 # doesn't crash if colors option is invalid)
709 712 self.magic_colors(rc.colors)
710 713
711 714 # Set calling of pdb on exceptions
712 715 self.call_pdb = rc.pdb
713 716
714 717 # Load user aliases
715 718 for alias in rc.alias:
716 719 self.magic_alias(alias)
717 720
718 721 self.hooks.late_startup_hook()
719 722
720 723 for cmd in self.rc.autoexec:
721 724 #print "autoexec>",cmd #dbg
722 725 self.api.runlines(cmd)
723 726
724 727 batchrun = False
725 728 for batchfile in [path(arg) for arg in self.rc.args
726 729 if arg.lower().endswith('.ipy')]:
727 730 if not batchfile.isfile():
728 731 print "No such batch file:", batchfile
729 732 continue
730 733 self.api.runlines(batchfile.text())
731 734 batchrun = True
732 735 # without -i option, exit after running the batch file
733 736 if batchrun and not self.rc.interact:
734 737 self.exit_now = True
735 738
736 739 def add_builtins(self):
737 740 """Store ipython references into the builtin namespace.
738 741
739 742 Some parts of ipython operate via builtins injected here, which hold a
740 743 reference to IPython itself."""
741 744
742 745 # TODO: deprecate all of these, they are unsafe
743 746 builtins_new = dict(__IPYTHON__ = self,
744 747 ip_set_hook = self.set_hook,
745 748 jobs = self.jobs,
746 749 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),
747 750 ipalias = wrap_deprecated(self.ipalias),
748 751 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
749 752 #_ip = self.api
750 753 )
751 754 for biname,bival in builtins_new.items():
752 755 try:
753 756 # store the orignal value so we can restore it
754 757 self.builtins_added[biname] = __builtin__.__dict__[biname]
755 758 except KeyError:
756 759 # or mark that it wasn't defined, and we'll just delete it at
757 760 # cleanup
758 761 self.builtins_added[biname] = Undefined
759 762 __builtin__.__dict__[biname] = bival
760 763
761 764 # Keep in the builtins a flag for when IPython is active. We set it
762 765 # with setdefault so that multiple nested IPythons don't clobber one
763 766 # another. Each will increase its value by one upon being activated,
764 767 # which also gives us a way to determine the nesting level.
765 768 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
766 769
767 770 def clean_builtins(self):
768 771 """Remove any builtins which might have been added by add_builtins, or
769 772 restore overwritten ones to their previous values."""
770 773 for biname,bival in self.builtins_added.items():
771 774 if bival is Undefined:
772 775 del __builtin__.__dict__[biname]
773 776 else:
774 777 __builtin__.__dict__[biname] = bival
775 778 self.builtins_added.clear()
776 779
777 780 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
778 781 """set_hook(name,hook) -> sets an internal IPython hook.
779 782
780 783 IPython exposes some of its internal API as user-modifiable hooks. By
781 784 adding your function to one of these hooks, you can modify IPython's
782 785 behavior to call at runtime your own routines."""
783 786
784 787 # At some point in the future, this should validate the hook before it
785 788 # accepts it. Probably at least check that the hook takes the number
786 789 # of args it's supposed to.
787 790
788 791 f = new.instancemethod(hook,self,self.__class__)
789 792
790 793 # check if the hook is for strdispatcher first
791 794 if str_key is not None:
792 795 sdp = self.strdispatchers.get(name, StrDispatch())
793 796 sdp.add_s(str_key, f, priority )
794 797 self.strdispatchers[name] = sdp
795 798 return
796 799 if re_key is not None:
797 800 sdp = self.strdispatchers.get(name, StrDispatch())
798 801 sdp.add_re(re.compile(re_key), f, priority )
799 802 self.strdispatchers[name] = sdp
800 803 return
801 804
802 805 dp = getattr(self.hooks, name, None)
803 806 if name not in IPython.hooks.__all__:
804 807 print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
805 808 if not dp:
806 809 dp = IPython.hooks.CommandChainDispatcher()
807 810
808 811 try:
809 812 dp.add(f,priority)
810 813 except AttributeError:
811 814 # it was not commandchain, plain old func - replace
812 815 dp = f
813 816
814 817 setattr(self.hooks,name, dp)
815 818
816 819
817 820 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
818 821
819 822 def set_crash_handler(self,crashHandler):
820 823 """Set the IPython crash handler.
821 824
822 825 This must be a callable with a signature suitable for use as
823 826 sys.excepthook."""
824 827
825 828 # Install the given crash handler as the Python exception hook
826 829 sys.excepthook = crashHandler
827 830
828 831 # The instance will store a pointer to this, so that runtime code
829 832 # (such as magics) can access it. This is because during the
830 833 # read-eval loop, it gets temporarily overwritten (to deal with GUI
831 834 # frameworks).
832 835 self.sys_excepthook = sys.excepthook
833 836
834 837
835 838 def set_custom_exc(self,exc_tuple,handler):
836 839 """set_custom_exc(exc_tuple,handler)
837 840
838 841 Set a custom exception handler, which will be called if any of the
839 842 exceptions in exc_tuple occur in the mainloop (specifically, in the
840 843 runcode() method.
841 844
842 845 Inputs:
843 846
844 847 - exc_tuple: a *tuple* of valid exceptions to call the defined
845 848 handler for. It is very important that you use a tuple, and NOT A
846 849 LIST here, because of the way Python's except statement works. If
847 850 you only want to trap a single exception, use a singleton tuple:
848 851
849 852 exc_tuple == (MyCustomException,)
850 853
851 854 - handler: this must be defined as a function with the following
852 855 basic interface: def my_handler(self,etype,value,tb).
853 856
854 857 This will be made into an instance method (via new.instancemethod)
855 858 of IPython itself, and it will be called if any of the exceptions
856 859 listed in the exc_tuple are caught. If the handler is None, an
857 860 internal basic one is used, which just prints basic info.
858 861
859 862 WARNING: by putting in your own exception handler into IPython's main
860 863 execution loop, you run a very good chance of nasty crashes. This
861 864 facility should only be used if you really know what you are doing."""
862 865
863 866 assert type(exc_tuple)==type(()) , \
864 867 "The custom exceptions must be given AS A TUPLE."
865 868
866 869 def dummy_handler(self,etype,value,tb):
867 870 print '*** Simple custom exception handler ***'
868 871 print 'Exception type :',etype
869 872 print 'Exception value:',value
870 873 print 'Traceback :',tb
871 874 print 'Source code :','\n'.join(self.buffer)
872 875
873 876 if handler is None: handler = dummy_handler
874 877
875 878 self.CustomTB = new.instancemethod(handler,self,self.__class__)
876 879 self.custom_exceptions = exc_tuple
877 880
878 881 def set_custom_completer(self,completer,pos=0):
879 882 """set_custom_completer(completer,pos=0)
880 883
881 884 Adds a new custom completer function.
882 885
883 886 The position argument (defaults to 0) is the index in the completers
884 887 list where you want the completer to be inserted."""
885 888
886 889 newcomp = new.instancemethod(completer,self.Completer,
887 890 self.Completer.__class__)
888 891 self.Completer.matchers.insert(pos,newcomp)
889 892
890 893 def set_completer(self):
891 894 """reset readline's completer to be our own."""
892 895 self.readline.set_completer(self.Completer.complete)
893 896
894 897 def _get_call_pdb(self):
895 898 return self._call_pdb
896 899
897 900 def _set_call_pdb(self,val):
898 901
899 902 if val not in (0,1,False,True):
900 903 raise ValueError,'new call_pdb value must be boolean'
901 904
902 905 # store value in instance
903 906 self._call_pdb = val
904 907
905 908 # notify the actual exception handlers
906 909 self.InteractiveTB.call_pdb = val
907 910 if self.isthreaded:
908 911 try:
909 912 self.sys_excepthook.call_pdb = val
910 913 except:
911 914 warn('Failed to activate pdb for threaded exception handler')
912 915
913 916 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
914 917 'Control auto-activation of pdb at exceptions')
915 918
916 919
917 920 # These special functions get installed in the builtin namespace, to
918 921 # provide programmatic (pure python) access to magics, aliases and system
919 922 # calls. This is important for logging, user scripting, and more.
920 923
921 924 # We are basically exposing, via normal python functions, the three
922 925 # mechanisms in which ipython offers special call modes (magics for
923 926 # internal control, aliases for direct system access via pre-selected
924 927 # names, and !cmd for calling arbitrary system commands).
925 928
926 929 def ipmagic(self,arg_s):
927 930 """Call a magic function by name.
928 931
929 932 Input: a string containing the name of the magic function to call and any
930 933 additional arguments to be passed to the magic.
931 934
932 935 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
933 936 prompt:
934 937
935 938 In[1]: %name -opt foo bar
936 939
937 940 To call a magic without arguments, simply use ipmagic('name').
938 941
939 942 This provides a proper Python function to call IPython's magics in any
940 943 valid Python code you can type at the interpreter, including loops and
941 944 compound statements. It is added by IPython to the Python builtin
942 945 namespace upon initialization."""
943 946
944 947 args = arg_s.split(' ',1)
945 948 magic_name = args[0]
946 949 magic_name = magic_name.lstrip(self.ESC_MAGIC)
947 950
948 951 try:
949 952 magic_args = args[1]
950 953 except IndexError:
951 954 magic_args = ''
952 955 fn = getattr(self,'magic_'+magic_name,None)
953 956 if fn is None:
954 957 error("Magic function `%s` not found." % magic_name)
955 958 else:
956 959 magic_args = self.var_expand(magic_args,1)
957 960 return fn(magic_args)
958 961
959 962 def ipalias(self,arg_s):
960 963 """Call an alias by name.
961 964
962 965 Input: a string containing the name of the alias to call and any
963 966 additional arguments to be passed to the magic.
964 967
965 968 ipalias('name -opt foo bar') is equivalent to typing at the ipython
966 969 prompt:
967 970
968 971 In[1]: name -opt foo bar
969 972
970 973 To call an alias without arguments, simply use ipalias('name').
971 974
972 975 This provides a proper Python function to call IPython's aliases in any
973 976 valid Python code you can type at the interpreter, including loops and
974 977 compound statements. It is added by IPython to the Python builtin
975 978 namespace upon initialization."""
976 979
977 980 args = arg_s.split(' ',1)
978 981 alias_name = args[0]
979 982 try:
980 983 alias_args = args[1]
981 984 except IndexError:
982 985 alias_args = ''
983 986 if alias_name in self.alias_table:
984 987 self.call_alias(alias_name,alias_args)
985 988 else:
986 989 error("Alias `%s` not found." % alias_name)
987 990
988 991 def ipsystem(self,arg_s):
989 992 """Make a system call, using IPython."""
990 993
991 994 self.system(arg_s)
992 995
993 996 def complete(self,text):
994 997 """Return a sorted list of all possible completions on text.
995 998
996 999 Inputs:
997 1000
998 1001 - text: a string of text to be completed on.
999 1002
1000 1003 This is a wrapper around the completion mechanism, similar to what
1001 1004 readline does at the command line when the TAB key is hit. By
1002 1005 exposing it as a method, it can be used by other non-readline
1003 1006 environments (such as GUIs) for text completion.
1004 1007
1005 1008 Simple usage example:
1006 1009
1007 1010 In [1]: x = 'hello'
1008 1011
1009 1012 In [2]: __IP.complete('x.l')
1010 1013 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
1011 1014
1012 1015 complete = self.Completer.complete
1013 1016 state = 0
1014 1017 # use a dict so we get unique keys, since ipyhton's multiple
1015 1018 # completers can return duplicates. When we make 2.4 a requirement,
1016 1019 # start using sets instead, which are faster.
1017 1020 comps = {}
1018 1021 while True:
1019 1022 newcomp = complete(text,state,line_buffer=text)
1020 1023 if newcomp is None:
1021 1024 break
1022 1025 comps[newcomp] = 1
1023 1026 state += 1
1024 1027 outcomps = comps.keys()
1025 1028 outcomps.sort()
1026 1029 return outcomps
1027 1030
1028 1031 def set_completer_frame(self, frame=None):
1029 1032 if frame:
1030 1033 self.Completer.namespace = frame.f_locals
1031 1034 self.Completer.global_namespace = frame.f_globals
1032 1035 else:
1033 1036 self.Completer.namespace = self.user_ns
1034 1037 self.Completer.global_namespace = self.user_global_ns
1035 1038
1036 1039 def init_auto_alias(self):
1037 1040 """Define some aliases automatically.
1038 1041
1039 1042 These are ALL parameter-less aliases"""
1040 1043
1041 1044 for alias,cmd in self.auto_alias:
1042 1045 self.getapi().defalias(alias,cmd)
1043 1046
1044 1047
1045 1048 def alias_table_validate(self,verbose=0):
1046 1049 """Update information about the alias table.
1047 1050
1048 1051 In particular, make sure no Python keywords/builtins are in it."""
1049 1052
1050 1053 no_alias = self.no_alias
1051 1054 for k in self.alias_table.keys():
1052 1055 if k in no_alias:
1053 1056 del self.alias_table[k]
1054 1057 if verbose:
1055 1058 print ("Deleting alias <%s>, it's a Python "
1056 1059 "keyword or builtin." % k)
1057 1060
1058 1061 def set_autoindent(self,value=None):
1059 1062 """Set the autoindent flag, checking for readline support.
1060 1063
1061 1064 If called with no arguments, it acts as a toggle."""
1062 1065
1063 1066 if not self.has_readline:
1064 1067 if os.name == 'posix':
1065 1068 warn("The auto-indent feature requires the readline library")
1066 1069 self.autoindent = 0
1067 1070 return
1068 1071 if value is None:
1069 1072 self.autoindent = not self.autoindent
1070 1073 else:
1071 1074 self.autoindent = value
1072 1075
1073 1076 def rc_set_toggle(self,rc_field,value=None):
1074 1077 """Set or toggle a field in IPython's rc config. structure.
1075 1078
1076 1079 If called with no arguments, it acts as a toggle.
1077 1080
1078 1081 If called with a non-existent field, the resulting AttributeError
1079 1082 exception will propagate out."""
1080 1083
1081 1084 rc_val = getattr(self.rc,rc_field)
1082 1085 if value is None:
1083 1086 value = not rc_val
1084 1087 setattr(self.rc,rc_field,value)
1085 1088
1086 1089 def user_setup(self,ipythondir,rc_suffix,mode='install'):
1087 1090 """Install the user configuration directory.
1088 1091
1089 1092 Can be called when running for the first time or to upgrade the user's
1090 1093 .ipython/ directory with the mode parameter. Valid modes are 'install'
1091 1094 and 'upgrade'."""
1092 1095
1093 1096 def wait():
1094 1097 try:
1095 1098 raw_input("Please press <RETURN> to start IPython.")
1096 1099 except EOFError:
1097 1100 print >> Term.cout
1098 1101 print '*'*70
1099 1102
1100 1103 cwd = os.getcwd() # remember where we started
1101 1104 glb = glob.glob
1102 1105 print '*'*70
1103 1106 if mode == 'install':
1104 1107 print \
1105 1108 """Welcome to IPython. I will try to create a personal configuration directory
1106 1109 where you can customize many aspects of IPython's functionality in:\n"""
1107 1110 else:
1108 1111 print 'I am going to upgrade your configuration in:'
1109 1112
1110 1113 print ipythondir
1111 1114
1112 1115 rcdirend = os.path.join('IPython','UserConfig')
1113 1116 cfg = lambda d: os.path.join(d,rcdirend)
1114 1117 try:
1115 1118 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
1116 1119 print "Initializing from configuration",rcdir
1117 1120 except IndexError:
1118 1121 warning = """
1119 1122 Installation error. IPython's directory was not found.
1120 1123
1121 1124 Check the following:
1122 1125
1123 1126 The ipython/IPython directory should be in a directory belonging to your
1124 1127 PYTHONPATH environment variable (that is, it should be in a directory
1125 1128 belonging to sys.path). You can copy it explicitly there or just link to it.
1126 1129
1127 1130 IPython will create a minimal default configuration for you.
1128 1131
1129 1132 """
1130 1133 warn(warning)
1131 1134 wait()
1132 1135
1133 1136 if sys.platform =='win32':
1134 1137 inif = 'ipythonrc.ini'
1135 1138 else:
1136 1139 inif = 'ipythonrc'
1137 1140 minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }
1138 1141 os.makedirs(ipythondir, mode = 0777)
1139 1142 for f, cont in minimal_setup.items():
1140 1143 open(ipythondir + '/' + f,'w').write(cont)
1141 1144
1142 1145 return
1143 1146
1144 1147 if mode == 'install':
1145 1148 try:
1146 1149 shutil.copytree(rcdir,ipythondir)
1147 1150 os.chdir(ipythondir)
1148 1151 rc_files = glb("ipythonrc*")
1149 1152 for rc_file in rc_files:
1150 1153 os.rename(rc_file,rc_file+rc_suffix)
1151 1154 except:
1152 1155 warning = """
1153 1156
1154 1157 There was a problem with the installation:
1155 1158 %s
1156 1159 Try to correct it or contact the developers if you think it's a bug.
1157 1160 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
1158 1161 warn(warning)
1159 1162 wait()
1160 1163 return
1161 1164
1162 1165 elif mode == 'upgrade':
1163 1166 try:
1164 1167 os.chdir(ipythondir)
1165 1168 except:
1166 1169 print """
1167 1170 Can not upgrade: changing to directory %s failed. Details:
1168 1171 %s
1169 1172 """ % (ipythondir,sys.exc_info()[1])
1170 1173 wait()
1171 1174 return
1172 1175 else:
1173 1176 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
1174 1177 for new_full_path in sources:
1175 1178 new_filename = os.path.basename(new_full_path)
1176 1179 if new_filename.startswith('ipythonrc'):
1177 1180 new_filename = new_filename + rc_suffix
1178 1181 # The config directory should only contain files, skip any
1179 1182 # directories which may be there (like CVS)
1180 1183 if os.path.isdir(new_full_path):
1181 1184 continue
1182 1185 if os.path.exists(new_filename):
1183 1186 old_file = new_filename+'.old'
1184 1187 if os.path.exists(old_file):
1185 1188 os.remove(old_file)
1186 1189 os.rename(new_filename,old_file)
1187 1190 shutil.copy(new_full_path,new_filename)
1188 1191 else:
1189 1192 raise ValueError,'unrecognized mode for install:',`mode`
1190 1193
1191 1194 # Fix line-endings to those native to each platform in the config
1192 1195 # directory.
1193 1196 try:
1194 1197 os.chdir(ipythondir)
1195 1198 except:
1196 1199 print """
1197 1200 Problem: changing to directory %s failed.
1198 1201 Details:
1199 1202 %s
1200 1203
1201 1204 Some configuration files may have incorrect line endings. This should not
1202 1205 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
1203 1206 wait()
1204 1207 else:
1205 1208 for fname in glb('ipythonrc*'):
1206 1209 try:
1207 1210 native_line_ends(fname,backup=0)
1208 1211 except IOError:
1209 1212 pass
1210 1213
1211 1214 if mode == 'install':
1212 1215 print """
1213 1216 Successful installation!
1214 1217
1215 1218 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
1216 1219 IPython manual (there are both HTML and PDF versions supplied with the
1217 1220 distribution) to make sure that your system environment is properly configured
1218 1221 to take advantage of IPython's features.
1219 1222
1220 1223 Important note: the configuration system has changed! The old system is
1221 1224 still in place, but its setting may be partly overridden by the settings in
1222 1225 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
1223 1226 if some of the new settings bother you.
1224 1227
1225 1228 """
1226 1229 else:
1227 1230 print """
1228 1231 Successful upgrade!
1229 1232
1230 1233 All files in your directory:
1231 1234 %(ipythondir)s
1232 1235 which would have been overwritten by the upgrade were backed up with a .old
1233 1236 extension. If you had made particular customizations in those files you may
1234 1237 want to merge them back into the new files.""" % locals()
1235 1238 wait()
1236 1239 os.chdir(cwd)
1237 1240 # end user_setup()
1238 1241
1239 1242 def atexit_operations(self):
1240 1243 """This will be executed at the time of exit.
1241 1244
1242 1245 Saving of persistent data should be performed here. """
1243 1246
1244 1247 #print '*** IPython exit cleanup ***' # dbg
1245 1248 # input history
1246 1249 self.savehist()
1247 1250
1248 1251 # Cleanup all tempfiles left around
1249 1252 for tfile in self.tempfiles:
1250 1253 try:
1251 1254 os.unlink(tfile)
1252 1255 except OSError:
1253 1256 pass
1254 1257
1255 1258 self.hooks.shutdown_hook()
1256 1259
1257 1260 def savehist(self):
1258 1261 """Save input history to a file (via readline library)."""
1259 1262
1260 1263 if not self.has_readline:
1261 1264 return
1262 1265
1263 1266 try:
1264 1267 self.readline.write_history_file(self.histfile)
1265 1268 except:
1266 1269 print 'Unable to save IPython command history to file: ' + \
1267 1270 `self.histfile`
1268 1271
1269 1272 def reloadhist(self):
1270 1273 """Reload the input history from disk file."""
1271 1274
1272 1275 if self.has_readline:
1273 1276 try:
1274 1277 self.readline.clear_history()
1275 1278 self.readline.read_history_file(self.shell.histfile)
1276 1279 except AttributeError:
1277 1280 pass
1278 1281
1279 1282
1280 1283 def history_saving_wrapper(self, func):
1281 1284 """ Wrap func for readline history saving
1282 1285
1283 1286 Convert func into callable that saves & restores
1284 1287 history around the call """
1285 1288
1286 1289 if not self.has_readline:
1287 1290 return func
1288 1291
1289 1292 def wrapper():
1290 1293 self.savehist()
1291 1294 try:
1292 1295 func()
1293 1296 finally:
1294 1297 readline.read_history_file(self.histfile)
1295 1298 return wrapper
1296 1299
1297 1300
1298 1301 def pre_readline(self):
1299 1302 """readline hook to be used at the start of each line.
1300 1303
1301 1304 Currently it handles auto-indent only."""
1302 1305
1303 1306 #debugx('self.indent_current_nsp','pre_readline:')
1304 1307
1305 1308 if self.rl_do_indent:
1306 1309 self.readline.insert_text(self.indent_current_str())
1307 1310 if self.rl_next_input is not None:
1308 1311 self.readline.insert_text(self.rl_next_input)
1309 1312 self.rl_next_input = None
1310 1313
1311 1314 def init_readline(self):
1312 1315 """Command history completion/saving/reloading."""
1313 1316
1314 1317
1315 1318 import IPython.rlineimpl as readline
1316 1319
1317 1320 if not readline.have_readline:
1318 1321 self.has_readline = 0
1319 1322 self.readline = None
1320 1323 # no point in bugging windows users with this every time:
1321 1324 warn('Readline services not available on this platform.')
1322 1325 else:
1323 1326 sys.modules['readline'] = readline
1324 1327 import atexit
1325 1328 from IPython.completer import IPCompleter
1326 1329 self.Completer = IPCompleter(self,
1327 1330 self.user_ns,
1328 1331 self.user_global_ns,
1329 1332 self.rc.readline_omit__names,
1330 1333 self.alias_table)
1331 1334 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1332 1335 self.strdispatchers['complete_command'] = sdisp
1333 1336 self.Completer.custom_completers = sdisp
1334 1337 # Platform-specific configuration
1335 1338 if os.name == 'nt':
1336 1339 self.readline_startup_hook = readline.set_pre_input_hook
1337 1340 else:
1338 1341 self.readline_startup_hook = readline.set_startup_hook
1339 1342
1340 1343 # Load user's initrc file (readline config)
1341 1344 # Or if libedit is used, load editrc.
1342 1345 inputrc_name = os.environ.get('INPUTRC')
1343 1346 if inputrc_name is None:
1344 1347 home_dir = get_home_dir()
1345 1348 if home_dir is not None:
1346 1349 inputrc_name = '.inputrc'
1347 1350 if readline.uses_libedit:
1348 1351 inputrc_name = '.editrc'
1349 1352 inputrc_name = os.path.join(home_dir, inputrc_name)
1350 1353 if os.path.isfile(inputrc_name):
1351 1354 try:
1352 1355 readline.read_init_file(inputrc_name)
1353 1356 except:
1354 1357 warn('Problems reading readline initialization file <%s>'
1355 1358 % inputrc_name)
1356 1359
1357 1360 self.has_readline = 1
1358 1361 self.readline = readline
1359 1362 # save this in sys so embedded copies can restore it properly
1360 1363 sys.ipcompleter = self.Completer.complete
1361 1364 self.set_completer()
1362 1365
1363 1366 # Configure readline according to user's prefs
1364 1367 # This is only done if GNU readline is being used. If libedit
1365 1368 # is being used (as on Leopard) the readline config is
1366 1369 # not run as the syntax for libedit is different.
1367 1370 if not readline.uses_libedit:
1368 1371 for rlcommand in self.rc.readline_parse_and_bind:
1369 1372 readline.parse_and_bind(rlcommand)
1370 1373
1371 1374 # remove some chars from the delimiters list
1372 1375 delims = readline.get_completer_delims()
1373 1376 delims = delims.translate(string._idmap,
1374 1377 self.rc.readline_remove_delims)
1375 1378 readline.set_completer_delims(delims)
1376 1379 # otherwise we end up with a monster history after a while:
1377 1380 readline.set_history_length(1000)
1378 1381 try:
1379 1382 #print '*** Reading readline history' # dbg
1380 1383 readline.read_history_file(self.histfile)
1381 1384 except IOError:
1382 1385 pass # It doesn't exist yet.
1383 1386
1384 1387 atexit.register(self.atexit_operations)
1385 1388 del atexit
1386 1389
1387 1390 # Configure auto-indent for all platforms
1388 1391 self.set_autoindent(self.rc.autoindent)
1389 1392
1390 1393 def ask_yes_no(self,prompt,default=True):
1391 1394 if self.rc.quiet:
1392 1395 return True
1393 1396 return ask_yes_no(prompt,default)
1394 1397
1395 1398 def _should_recompile(self,e):
1396 1399 """Utility routine for edit_syntax_error"""
1397 1400
1398 1401 if e.filename in ('<ipython console>','<input>','<string>',
1399 1402 '<console>','<BackgroundJob compilation>',
1400 1403 None):
1401 1404
1402 1405 return False
1403 1406 try:
1404 1407 if (self.rc.autoedit_syntax and
1405 1408 not self.ask_yes_no('Return to editor to correct syntax error? '
1406 1409 '[Y/n] ','y')):
1407 1410 return False
1408 1411 except EOFError:
1409 1412 return False
1410 1413
1411 1414 def int0(x):
1412 1415 try:
1413 1416 return int(x)
1414 1417 except TypeError:
1415 1418 return 0
1416 1419 # always pass integer line and offset values to editor hook
1417 1420 self.hooks.fix_error_editor(e.filename,
1418 1421 int0(e.lineno),int0(e.offset),e.msg)
1419 1422 return True
1420 1423
1421 1424 def edit_syntax_error(self):
1422 1425 """The bottom half of the syntax error handler called in the main loop.
1423 1426
1424 1427 Loop until syntax error is fixed or user cancels.
1425 1428 """
1426 1429
1427 1430 while self.SyntaxTB.last_syntax_error:
1428 1431 # copy and clear last_syntax_error
1429 1432 err = self.SyntaxTB.clear_err_state()
1430 1433 if not self._should_recompile(err):
1431 1434 return
1432 1435 try:
1433 1436 # may set last_syntax_error again if a SyntaxError is raised
1434 1437 self.safe_execfile(err.filename,self.user_ns)
1435 1438 except:
1436 1439 self.showtraceback()
1437 1440 else:
1438 1441 try:
1439 1442 f = file(err.filename)
1440 1443 try:
1441 1444 sys.displayhook(f.read())
1442 1445 finally:
1443 1446 f.close()
1444 1447 except:
1445 1448 self.showtraceback()
1446 1449
1447 1450 def showsyntaxerror(self, filename=None):
1448 1451 """Display the syntax error that just occurred.
1449 1452
1450 1453 This doesn't display a stack trace because there isn't one.
1451 1454
1452 1455 If a filename is given, it is stuffed in the exception instead
1453 1456 of what was there before (because Python's parser always uses
1454 1457 "<string>" when reading from a string).
1455 1458 """
1456 1459 etype, value, last_traceback = sys.exc_info()
1457 1460
1458 1461 # See note about these variables in showtraceback() below
1459 1462 sys.last_type = etype
1460 1463 sys.last_value = value
1461 1464 sys.last_traceback = last_traceback
1462 1465
1463 1466 if filename and etype is SyntaxError:
1464 1467 # Work hard to stuff the correct filename in the exception
1465 1468 try:
1466 1469 msg, (dummy_filename, lineno, offset, line) = value
1467 1470 except:
1468 1471 # Not the format we expect; leave it alone
1469 1472 pass
1470 1473 else:
1471 1474 # Stuff in the right filename
1472 1475 try:
1473 1476 # Assume SyntaxError is a class exception
1474 1477 value = SyntaxError(msg, (filename, lineno, offset, line))
1475 1478 except:
1476 1479 # If that failed, assume SyntaxError is a string
1477 1480 value = msg, (filename, lineno, offset, line)
1478 1481 self.SyntaxTB(etype,value,[])
1479 1482
1480 1483 def debugger(self,force=False):
1481 1484 """Call the pydb/pdb debugger.
1482 1485
1483 1486 Keywords:
1484 1487
1485 1488 - force(False): by default, this routine checks the instance call_pdb
1486 1489 flag and does not actually invoke the debugger if the flag is false.
1487 1490 The 'force' option forces the debugger to activate even if the flag
1488 1491 is false.
1489 1492 """
1490 1493
1491 1494 if not (force or self.call_pdb):
1492 1495 return
1493 1496
1494 1497 if not hasattr(sys,'last_traceback'):
1495 1498 error('No traceback has been produced, nothing to debug.')
1496 1499 return
1497 1500
1498 1501 # use pydb if available
1499 1502 if Debugger.has_pydb:
1500 1503 from pydb import pm
1501 1504 else:
1502 1505 # fallback to our internal debugger
1503 1506 pm = lambda : self.InteractiveTB.debugger(force=True)
1504 1507 self.history_saving_wrapper(pm)()
1505 1508
1506 1509 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1507 1510 """Display the exception that just occurred.
1508 1511
1509 1512 If nothing is known about the exception, this is the method which
1510 1513 should be used throughout the code for presenting user tracebacks,
1511 1514 rather than directly invoking the InteractiveTB object.
1512 1515
1513 1516 A specific showsyntaxerror() also exists, but this method can take
1514 1517 care of calling it if needed, so unless you are explicitly catching a
1515 1518 SyntaxError exception, don't try to analyze the stack manually and
1516 1519 simply call this method."""
1517 1520
1518 1521
1519 1522 # Though this won't be called by syntax errors in the input line,
1520 1523 # there may be SyntaxError cases whith imported code.
1521 1524
1522 1525 try:
1523 1526 if exc_tuple is None:
1524 1527 etype, value, tb = sys.exc_info()
1525 1528 else:
1526 1529 etype, value, tb = exc_tuple
1527 1530
1528 1531 if etype is SyntaxError:
1529 1532 self.showsyntaxerror(filename)
1530 1533 elif etype is IPython.ipapi.UsageError:
1531 1534 print "UsageError:", value
1532 1535 else:
1533 1536 # WARNING: these variables are somewhat deprecated and not
1534 1537 # necessarily safe to use in a threaded environment, but tools
1535 1538 # like pdb depend on their existence, so let's set them. If we
1536 1539 # find problems in the field, we'll need to revisit their use.
1537 1540 sys.last_type = etype
1538 1541 sys.last_value = value
1539 1542 sys.last_traceback = tb
1540 1543
1541 1544 if etype in self.custom_exceptions:
1542 1545 self.CustomTB(etype,value,tb)
1543 1546 else:
1544 1547 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1545 1548 if self.InteractiveTB.call_pdb and self.has_readline:
1546 1549 # pdb mucks up readline, fix it back
1547 1550 self.set_completer()
1548 1551 except KeyboardInterrupt:
1549 1552 self.write("\nKeyboardInterrupt\n")
1550 1553
1551 1554
1552 1555
1553 1556 def mainloop(self,banner=None):
1554 1557 """Creates the local namespace and starts the mainloop.
1555 1558
1556 1559 If an optional banner argument is given, it will override the
1557 1560 internally created default banner."""
1558 1561
1559 1562 if self.rc.c: # Emulate Python's -c option
1560 1563 self.exec_init_cmd()
1561 1564 if banner is None:
1562 1565 if not self.rc.banner:
1563 1566 banner = ''
1564 1567 # banner is string? Use it directly!
1565 1568 elif isinstance(self.rc.banner,basestring):
1566 1569 banner = self.rc.banner
1567 1570 else:
1568 1571 banner = self.BANNER+self.banner2
1569 1572
1570 1573 while 1:
1571 1574 try:
1572 1575 self.interact(banner)
1573 1576 #self.interact_with_readline()
1574 1577 # XXX for testing of a readline-decoupled repl loop, call interact_with_readline above
1575 1578
1576 1579 break
1577 1580 except KeyboardInterrupt:
1578 1581 # this should not be necessary, but KeyboardInterrupt
1579 1582 # handling seems rather unpredictable...
1580 1583 self.write("\nKeyboardInterrupt in interact()\n")
1581 1584
1582 1585 def exec_init_cmd(self):
1583 1586 """Execute a command given at the command line.
1584 1587
1585 1588 This emulates Python's -c option."""
1586 1589
1587 1590 #sys.argv = ['-c']
1588 1591 self.push(self.prefilter(self.rc.c, False))
1589 1592 if not self.rc.interact:
1590 1593 self.exit_now = True
1591 1594
1592 1595 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1593 1596 """Embeds IPython into a running python program.
1594 1597
1595 1598 Input:
1596 1599
1597 1600 - header: An optional header message can be specified.
1598 1601
1599 1602 - local_ns, global_ns: working namespaces. If given as None, the
1600 1603 IPython-initialized one is updated with __main__.__dict__, so that
1601 1604 program variables become visible but user-specific configuration
1602 1605 remains possible.
1603 1606
1604 1607 - stack_depth: specifies how many levels in the stack to go to
1605 1608 looking for namespaces (when local_ns and global_ns are None). This
1606 1609 allows an intermediate caller to make sure that this function gets
1607 1610 the namespace from the intended level in the stack. By default (0)
1608 1611 it will get its locals and globals from the immediate caller.
1609 1612
1610 1613 Warning: it's possible to use this in a program which is being run by
1611 1614 IPython itself (via %run), but some funny things will happen (a few
1612 1615 globals get overwritten). In the future this will be cleaned up, as
1613 1616 there is no fundamental reason why it can't work perfectly."""
1614 1617
1615 1618 # Get locals and globals from caller
1616 1619 if local_ns is None or global_ns is None:
1617 1620 call_frame = sys._getframe(stack_depth).f_back
1618 1621
1619 1622 if local_ns is None:
1620 1623 local_ns = call_frame.f_locals
1621 1624 if global_ns is None:
1622 1625 global_ns = call_frame.f_globals
1623 1626
1624 1627 # Update namespaces and fire up interpreter
1625 1628
1626 1629 # The global one is easy, we can just throw it in
1627 1630 self.user_global_ns = global_ns
1628 1631
1629 1632 # but the user/local one is tricky: ipython needs it to store internal
1630 1633 # data, but we also need the locals. We'll copy locals in the user
1631 1634 # one, but will track what got copied so we can delete them at exit.
1632 1635 # This is so that a later embedded call doesn't see locals from a
1633 1636 # previous call (which most likely existed in a separate scope).
1634 1637 local_varnames = local_ns.keys()
1635 1638 self.user_ns.update(local_ns)
1636 1639
1637 1640 # Patch for global embedding to make sure that things don't overwrite
1638 1641 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1639 1642 # FIXME. Test this a bit more carefully (the if.. is new)
1640 1643 if local_ns is None and global_ns is None:
1641 1644 self.user_global_ns.update(__main__.__dict__)
1642 1645
1643 1646 # make sure the tab-completer has the correct frame information, so it
1644 1647 # actually completes using the frame's locals/globals
1645 1648 self.set_completer_frame()
1646 1649
1647 1650 # before activating the interactive mode, we need to make sure that
1648 1651 # all names in the builtin namespace needed by ipython point to
1649 1652 # ourselves, and not to other instances.
1650 1653 self.add_builtins()
1651 1654
1652 1655 self.interact(header)
1653 1656
1654 1657 # now, purge out the user namespace from anything we might have added
1655 1658 # from the caller's local namespace
1656 1659 delvar = self.user_ns.pop
1657 1660 for var in local_varnames:
1658 1661 delvar(var,None)
1659 1662 # and clean builtins we may have overridden
1660 1663 self.clean_builtins()
1661 1664
1662 1665 def interact_prompt(self):
1663 1666 """ Print the prompt (in read-eval-print loop)
1664 1667
1665 1668 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1666 1669 used in standard IPython flow.
1667 1670 """
1668 1671 if self.more:
1669 1672 try:
1670 1673 prompt = self.hooks.generate_prompt(True)
1671 1674 except:
1672 1675 self.showtraceback()
1673 1676 if self.autoindent:
1674 1677 self.rl_do_indent = True
1675 1678
1676 1679 else:
1677 1680 try:
1678 1681 prompt = self.hooks.generate_prompt(False)
1679 1682 except:
1680 1683 self.showtraceback()
1681 1684 self.write(prompt)
1682 1685
1683 1686 def interact_handle_input(self,line):
1684 1687 """ Handle the input line (in read-eval-print loop)
1685 1688
1686 1689 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1687 1690 used in standard IPython flow.
1688 1691 """
1689 1692 if line.lstrip() == line:
1690 1693 self.shadowhist.add(line.strip())
1691 1694 lineout = self.prefilter(line,self.more)
1692 1695
1693 1696 if line.strip():
1694 1697 if self.more:
1695 1698 self.input_hist_raw[-1] += '%s\n' % line
1696 1699 else:
1697 1700 self.input_hist_raw.append('%s\n' % line)
1698 1701
1699 1702
1700 1703 self.more = self.push(lineout)
1701 1704 if (self.SyntaxTB.last_syntax_error and
1702 1705 self.rc.autoedit_syntax):
1703 1706 self.edit_syntax_error()
1704 1707
1705 1708 def interact_with_readline(self):
1706 1709 """ Demo of using interact_handle_input, interact_prompt
1707 1710
1708 1711 This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
1709 1712 it should work like this.
1710 1713 """
1711 1714 self.readline_startup_hook(self.pre_readline)
1712 1715 while not self.exit_now:
1713 1716 self.interact_prompt()
1714 1717 if self.more:
1715 1718 self.rl_do_indent = True
1716 1719 else:
1717 1720 self.rl_do_indent = False
1718 1721 line = raw_input_original().decode(self.stdin_encoding)
1719 1722 self.interact_handle_input(line)
1720 1723
1721 1724
1722 1725 def interact(self, banner=None):
1723 1726 """Closely emulate the interactive Python console.
1724 1727
1725 1728 The optional banner argument specify the banner to print
1726 1729 before the first interaction; by default it prints a banner
1727 1730 similar to the one printed by the real Python interpreter,
1728 1731 followed by the current class name in parentheses (so as not
1729 1732 to confuse this with the real interpreter -- since it's so
1730 1733 close!).
1731 1734
1732 1735 """
1733 1736
1734 1737 if self.exit_now:
1735 1738 # batch run -> do not interact
1736 1739 return
1737 1740 cprt = 'Type "copyright", "credits" or "license" for more information.'
1738 1741 if banner is None:
1739 1742 self.write("Python %s on %s\n%s\n(%s)\n" %
1740 1743 (sys.version, sys.platform, cprt,
1741 1744 self.__class__.__name__))
1742 1745 else:
1743 1746 self.write(banner)
1744 1747
1745 1748 more = 0
1746 1749
1747 1750 # Mark activity in the builtins
1748 1751 __builtin__.__dict__['__IPYTHON__active'] += 1
1749 1752
1750 1753 if self.has_readline:
1751 1754 self.readline_startup_hook(self.pre_readline)
1752 1755 # exit_now is set by a call to %Exit or %Quit
1753 1756
1754 1757 while not self.exit_now:
1755 1758 self.hooks.pre_prompt_hook()
1756 1759 if more:
1757 1760 try:
1758 1761 prompt = self.hooks.generate_prompt(True)
1759 1762 except:
1760 1763 self.showtraceback()
1761 1764 if self.autoindent:
1762 1765 self.rl_do_indent = True
1763 1766
1764 1767 else:
1765 1768 try:
1766 1769 prompt = self.hooks.generate_prompt(False)
1767 1770 except:
1768 1771 self.showtraceback()
1769 1772 try:
1770 1773 line = self.raw_input(prompt,more)
1771 1774 if self.exit_now:
1772 1775 # quick exit on sys.std[in|out] close
1773 1776 break
1774 1777 if self.autoindent:
1775 1778 self.rl_do_indent = False
1776 1779
1777 1780 except KeyboardInterrupt:
1778 1781 #double-guard against keyboardinterrupts during kbdint handling
1779 1782 try:
1780 1783 self.write('\nKeyboardInterrupt\n')
1781 1784 self.resetbuffer()
1782 1785 # keep cache in sync with the prompt counter:
1783 1786 self.outputcache.prompt_count -= 1
1784 1787
1785 1788 if self.autoindent:
1786 1789 self.indent_current_nsp = 0
1787 1790 more = 0
1788 1791 except KeyboardInterrupt:
1789 1792 pass
1790 1793 except EOFError:
1791 1794 if self.autoindent:
1792 1795 self.rl_do_indent = False
1793 1796 self.readline_startup_hook(None)
1794 1797 self.write('\n')
1795 1798 self.exit()
1796 1799 except bdb.BdbQuit:
1797 1800 warn('The Python debugger has exited with a BdbQuit exception.\n'
1798 1801 'Because of how pdb handles the stack, it is impossible\n'
1799 1802 'for IPython to properly format this particular exception.\n'
1800 1803 'IPython will resume normal operation.')
1801 1804 except:
1802 1805 # exceptions here are VERY RARE, but they can be triggered
1803 1806 # asynchronously by signal handlers, for example.
1804 1807 self.showtraceback()
1805 1808 else:
1806 1809 more = self.push(line)
1807 1810 if (self.SyntaxTB.last_syntax_error and
1808 1811 self.rc.autoedit_syntax):
1809 1812 self.edit_syntax_error()
1810 1813
1811 1814 # We are off again...
1812 1815 __builtin__.__dict__['__IPYTHON__active'] -= 1
1813 1816
1814 1817 def excepthook(self, etype, value, tb):
1815 1818 """One more defense for GUI apps that call sys.excepthook.
1816 1819
1817 1820 GUI frameworks like wxPython trap exceptions and call
1818 1821 sys.excepthook themselves. I guess this is a feature that
1819 1822 enables them to keep running after exceptions that would
1820 1823 otherwise kill their mainloop. This is a bother for IPython
1821 1824 which excepts to catch all of the program exceptions with a try:
1822 1825 except: statement.
1823 1826
1824 1827 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1825 1828 any app directly invokes sys.excepthook, it will look to the user like
1826 1829 IPython crashed. In order to work around this, we can disable the
1827 1830 CrashHandler and replace it with this excepthook instead, which prints a
1828 1831 regular traceback using our InteractiveTB. In this fashion, apps which
1829 1832 call sys.excepthook will generate a regular-looking exception from
1830 1833 IPython, and the CrashHandler will only be triggered by real IPython
1831 1834 crashes.
1832 1835
1833 1836 This hook should be used sparingly, only in places which are not likely
1834 1837 to be true IPython errors.
1835 1838 """
1836 1839 self.showtraceback((etype,value,tb),tb_offset=0)
1837 1840
1838 1841 def expand_aliases(self,fn,rest):
1839 1842 """ Expand multiple levels of aliases:
1840 1843
1841 1844 if:
1842 1845
1843 1846 alias foo bar /tmp
1844 1847 alias baz foo
1845 1848
1846 1849 then:
1847 1850
1848 1851 baz huhhahhei -> bar /tmp huhhahhei
1849 1852
1850 1853 """
1851 1854 line = fn + " " + rest
1852 1855
1853 1856 done = Set()
1854 1857 while 1:
1855 1858 pre,fn,rest = prefilter.splitUserInput(line,
1856 1859 prefilter.shell_line_split)
1857 1860 if fn in self.alias_table:
1858 1861 if fn in done:
1859 1862 warn("Cyclic alias definition, repeated '%s'" % fn)
1860 1863 return ""
1861 1864 done.add(fn)
1862 1865
1863 1866 l2 = self.transform_alias(fn,rest)
1864 1867 # dir -> dir
1865 1868 # print "alias",line, "->",l2 #dbg
1866 1869 if l2 == line:
1867 1870 break
1868 1871 # ls -> ls -F should not recurse forever
1869 1872 if l2.split(None,1)[0] == line.split(None,1)[0]:
1870 1873 line = l2
1871 1874 break
1872 1875
1873 1876 line=l2
1874 1877
1875 1878
1876 1879 # print "al expand to",line #dbg
1877 1880 else:
1878 1881 break
1879 1882
1880 1883 return line
1881 1884
1882 1885 def transform_alias(self, alias,rest=''):
1883 1886 """ Transform alias to system command string.
1884 1887 """
1885 1888 trg = self.alias_table[alias]
1886 1889
1887 1890 nargs,cmd = trg
1888 1891 # print trg #dbg
1889 1892 if ' ' in cmd and os.path.isfile(cmd):
1890 1893 cmd = '"%s"' % cmd
1891 1894
1892 1895 # Expand the %l special to be the user's input line
1893 1896 if cmd.find('%l') >= 0:
1894 1897 cmd = cmd.replace('%l',rest)
1895 1898 rest = ''
1896 1899 if nargs==0:
1897 1900 # Simple, argument-less aliases
1898 1901 cmd = '%s %s' % (cmd,rest)
1899 1902 else:
1900 1903 # Handle aliases with positional arguments
1901 1904 args = rest.split(None,nargs)
1902 1905 if len(args)< nargs:
1903 1906 error('Alias <%s> requires %s arguments, %s given.' %
1904 1907 (alias,nargs,len(args)))
1905 1908 return None
1906 1909 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1907 1910 # Now call the macro, evaluating in the user's namespace
1908 1911 #print 'new command: <%r>' % cmd # dbg
1909 1912 return cmd
1910 1913
1911 1914 def call_alias(self,alias,rest=''):
1912 1915 """Call an alias given its name and the rest of the line.
1913 1916
1914 1917 This is only used to provide backwards compatibility for users of
1915 1918 ipalias(), use of which is not recommended for anymore."""
1916 1919
1917 1920 # Now call the macro, evaluating in the user's namespace
1918 1921 cmd = self.transform_alias(alias, rest)
1919 1922 try:
1920 1923 self.system(cmd)
1921 1924 except:
1922 1925 self.showtraceback()
1923 1926
1924 1927 def indent_current_str(self):
1925 1928 """return the current level of indentation as a string"""
1926 1929 return self.indent_current_nsp * ' '
1927 1930
1928 1931 def autoindent_update(self,line):
1929 1932 """Keep track of the indent level."""
1930 1933
1931 1934 #debugx('line')
1932 1935 #debugx('self.indent_current_nsp')
1933 1936 if self.autoindent:
1934 1937 if line:
1935 1938 inisp = num_ini_spaces(line)
1936 1939 if inisp < self.indent_current_nsp:
1937 1940 self.indent_current_nsp = inisp
1938 1941
1939 1942 if line[-1] == ':':
1940 1943 self.indent_current_nsp += 4
1941 1944 elif dedent_re.match(line):
1942 1945 self.indent_current_nsp -= 4
1943 1946 else:
1944 1947 self.indent_current_nsp = 0
1945 1948
1946 1949 def runlines(self,lines):
1947 1950 """Run a string of one or more lines of source.
1948 1951
1949 1952 This method is capable of running a string containing multiple source
1950 1953 lines, as if they had been entered at the IPython prompt. Since it
1951 1954 exposes IPython's processing machinery, the given strings can contain
1952 1955 magic calls (%magic), special shell access (!cmd), etc."""
1953 1956
1954 1957 # We must start with a clean buffer, in case this is run from an
1955 1958 # interactive IPython session (via a magic, for example).
1956 1959 self.resetbuffer()
1957 1960 lines = lines.split('\n')
1958 1961 more = 0
1959 1962
1960 1963 for line in lines:
1961 1964 # skip blank lines so we don't mess up the prompt counter, but do
1962 1965 # NOT skip even a blank line if we are in a code block (more is
1963 1966 # true)
1964 1967
1965 1968
1966 1969 if line or more:
1967 1970 # push to raw history, so hist line numbers stay in sync
1968 1971 self.input_hist_raw.append("# " + line + "\n")
1969 1972 more = self.push(self.prefilter(line,more))
1970 1973 # IPython's runsource returns None if there was an error
1971 1974 # compiling the code. This allows us to stop processing right
1972 1975 # away, so the user gets the error message at the right place.
1973 1976 if more is None:
1974 1977 break
1975 1978 else:
1976 1979 self.input_hist_raw.append("\n")
1977 1980 # final newline in case the input didn't have it, so that the code
1978 1981 # actually does get executed
1979 1982 if more:
1980 1983 self.push('\n')
1981 1984
1982 1985 def runsource(self, source, filename='<input>', symbol='single'):
1983 1986 """Compile and run some source in the interpreter.
1984 1987
1985 1988 Arguments are as for compile_command().
1986 1989
1987 1990 One several things can happen:
1988 1991
1989 1992 1) The input is incorrect; compile_command() raised an
1990 1993 exception (SyntaxError or OverflowError). A syntax traceback
1991 1994 will be printed by calling the showsyntaxerror() method.
1992 1995
1993 1996 2) The input is incomplete, and more input is required;
1994 1997 compile_command() returned None. Nothing happens.
1995 1998
1996 1999 3) The input is complete; compile_command() returned a code
1997 2000 object. The code is executed by calling self.runcode() (which
1998 2001 also handles run-time exceptions, except for SystemExit).
1999 2002
2000 2003 The return value is:
2001 2004
2002 2005 - True in case 2
2003 2006
2004 2007 - False in the other cases, unless an exception is raised, where
2005 2008 None is returned instead. This can be used by external callers to
2006 2009 know whether to continue feeding input or not.
2007 2010
2008 2011 The return value can be used to decide whether to use sys.ps1 or
2009 2012 sys.ps2 to prompt the next line."""
2010 2013
2011 2014 # if the source code has leading blanks, add 'if 1:\n' to it
2012 2015 # this allows execution of indented pasted code. It is tempting
2013 2016 # to add '\n' at the end of source to run commands like ' a=1'
2014 2017 # directly, but this fails for more complicated scenarios
2015 2018 source=source.encode(self.stdin_encoding)
2016 2019 if source[:1] in [' ', '\t']:
2017 2020 source = 'if 1:\n%s' % source
2018 2021
2019 2022 try:
2020 2023 code = self.compile(source,filename,symbol)
2021 2024 except (OverflowError, SyntaxError, ValueError, TypeError):
2022 2025 # Case 1
2023 2026 self.showsyntaxerror(filename)
2024 2027 return None
2025 2028
2026 2029 if code is None:
2027 2030 # Case 2
2028 2031 return True
2029 2032
2030 2033 # Case 3
2031 2034 # We store the code object so that threaded shells and
2032 2035 # custom exception handlers can access all this info if needed.
2033 2036 # The source corresponding to this can be obtained from the
2034 2037 # buffer attribute as '\n'.join(self.buffer).
2035 2038 self.code_to_run = code
2036 2039 # now actually execute the code object
2037 2040 if self.runcode(code) == 0:
2038 2041 return False
2039 2042 else:
2040 2043 return None
2041 2044
2042 2045 def runcode(self,code_obj):
2043 2046 """Execute a code object.
2044 2047
2045 2048 When an exception occurs, self.showtraceback() is called to display a
2046 2049 traceback.
2047 2050
2048 2051 Return value: a flag indicating whether the code to be run completed
2049 2052 successfully:
2050 2053
2051 2054 - 0: successful execution.
2052 2055 - 1: an error occurred.
2053 2056 """
2054 2057
2055 2058 # Set our own excepthook in case the user code tries to call it
2056 2059 # directly, so that the IPython crash handler doesn't get triggered
2057 2060 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2058 2061
2059 2062 # we save the original sys.excepthook in the instance, in case config
2060 2063 # code (such as magics) needs access to it.
2061 2064 self.sys_excepthook = old_excepthook
2062 2065 outflag = 1 # happens in more places, so it's easier as default
2063 2066 try:
2064 2067 try:
2065 2068 self.hooks.pre_runcode_hook()
2066 2069 # Embedded instances require separate global/local namespaces
2067 2070 # so they can see both the surrounding (local) namespace and
2068 2071 # the module-level globals when called inside another function.
2069 2072 if self.embedded:
2070 2073 exec code_obj in self.user_global_ns, self.user_ns
2071 2074 # Normal (non-embedded) instances should only have a single
2072 2075 # namespace for user code execution, otherwise functions won't
2073 2076 # see interactive top-level globals.
2074 2077 else:
2075 2078 exec code_obj in self.user_ns
2076 2079 finally:
2077 2080 # Reset our crash handler in place
2078 2081 sys.excepthook = old_excepthook
2079 2082 except SystemExit:
2080 2083 self.resetbuffer()
2081 2084 self.showtraceback()
2082 2085 warn("Type %exit or %quit to exit IPython "
2083 2086 "(%Exit or %Quit do so unconditionally).",level=1)
2084 2087 except self.custom_exceptions:
2085 2088 etype,value,tb = sys.exc_info()
2086 2089 self.CustomTB(etype,value,tb)
2087 2090 except:
2088 2091 self.showtraceback()
2089 2092 else:
2090 2093 outflag = 0
2091 2094 if softspace(sys.stdout, 0):
2092 2095 print
2093 2096 # Flush out code object which has been run (and source)
2094 2097 self.code_to_run = None
2095 2098 return outflag
2096 2099
2097 2100 def push(self, line):
2098 2101 """Push a line to the interpreter.
2099 2102
2100 2103 The line should not have a trailing newline; it may have
2101 2104 internal newlines. The line is appended to a buffer and the
2102 2105 interpreter's runsource() method is called with the
2103 2106 concatenated contents of the buffer as source. If this
2104 2107 indicates that the command was executed or invalid, the buffer
2105 2108 is reset; otherwise, the command is incomplete, and the buffer
2106 2109 is left as it was after the line was appended. The return
2107 2110 value is 1 if more input is required, 0 if the line was dealt
2108 2111 with in some way (this is the same as runsource()).
2109 2112 """
2110 2113
2111 2114 # autoindent management should be done here, and not in the
2112 2115 # interactive loop, since that one is only seen by keyboard input. We
2113 2116 # need this done correctly even for code run via runlines (which uses
2114 2117 # push).
2115 2118
2116 2119 #print 'push line: <%s>' % line # dbg
2117 2120 for subline in line.splitlines():
2118 2121 self.autoindent_update(subline)
2119 2122 self.buffer.append(line)
2120 2123 more = self.runsource('\n'.join(self.buffer), self.filename)
2121 2124 if not more:
2122 2125 self.resetbuffer()
2123 2126 return more
2124 2127
2125 2128 def split_user_input(self, line):
2126 2129 # This is really a hold-over to support ipapi and some extensions
2127 2130 return prefilter.splitUserInput(line)
2128 2131
2129 2132 def resetbuffer(self):
2130 2133 """Reset the input buffer."""
2131 2134 self.buffer[:] = []
2132 2135
2133 2136 def raw_input(self,prompt='',continue_prompt=False):
2134 2137 """Write a prompt and read a line.
2135 2138
2136 2139 The returned line does not include the trailing newline.
2137 2140 When the user enters the EOF key sequence, EOFError is raised.
2138 2141
2139 2142 Optional inputs:
2140 2143
2141 2144 - prompt(''): a string to be printed to prompt the user.
2142 2145
2143 2146 - continue_prompt(False): whether this line is the first one or a
2144 2147 continuation in a sequence of inputs.
2145 2148 """
2146 2149
2147 2150 # Code run by the user may have modified the readline completer state.
2148 2151 # We must ensure that our completer is back in place.
2149 2152 if self.has_readline:
2150 2153 self.set_completer()
2151 2154
2152 2155 try:
2153 2156 line = raw_input_original(prompt).decode(self.stdin_encoding)
2154 2157 except ValueError:
2155 2158 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2156 2159 " or sys.stdout.close()!\nExiting IPython!")
2157 2160 self.exit_now = True
2158 2161 return ""
2159 2162
2160 2163 # Try to be reasonably smart about not re-indenting pasted input more
2161 2164 # than necessary. We do this by trimming out the auto-indent initial
2162 2165 # spaces, if the user's actual input started itself with whitespace.
2163 2166 #debugx('self.buffer[-1]')
2164 2167
2165 2168 if self.autoindent:
2166 2169 if num_ini_spaces(line) > self.indent_current_nsp:
2167 2170 line = line[self.indent_current_nsp:]
2168 2171 self.indent_current_nsp = 0
2169 2172
2170 2173 # store the unfiltered input before the user has any chance to modify
2171 2174 # it.
2172 2175 if line.strip():
2173 2176 if continue_prompt:
2174 2177 self.input_hist_raw[-1] += '%s\n' % line
2175 2178 if self.has_readline: # and some config option is set?
2176 2179 try:
2177 2180 histlen = self.readline.get_current_history_length()
2178 2181 if histlen > 1:
2179 2182 newhist = self.input_hist_raw[-1].rstrip()
2180 2183 self.readline.remove_history_item(histlen-1)
2181 2184 self.readline.replace_history_item(histlen-2,
2182 2185 newhist.encode(self.stdin_encoding))
2183 2186 except AttributeError:
2184 2187 pass # re{move,place}_history_item are new in 2.4.
2185 2188 else:
2186 2189 self.input_hist_raw.append('%s\n' % line)
2187 2190 # only entries starting at first column go to shadow history
2188 2191 if line.lstrip() == line:
2189 2192 self.shadowhist.add(line.strip())
2190 2193 elif not continue_prompt:
2191 2194 self.input_hist_raw.append('\n')
2192 2195 try:
2193 2196 lineout = self.prefilter(line,continue_prompt)
2194 2197 except:
2195 2198 # blanket except, in case a user-defined prefilter crashes, so it
2196 2199 # can't take all of ipython with it.
2197 2200 self.showtraceback()
2198 2201 return ''
2199 2202 else:
2200 2203 return lineout
2201 2204
2202 2205 def _prefilter(self, line, continue_prompt):
2203 2206 """Calls different preprocessors, depending on the form of line."""
2204 2207
2205 2208 # All handlers *must* return a value, even if it's blank ('').
2206 2209
2207 2210 # Lines are NOT logged here. Handlers should process the line as
2208 2211 # needed, update the cache AND log it (so that the input cache array
2209 2212 # stays synced).
2210 2213
2211 2214 #.....................................................................
2212 2215 # Code begins
2213 2216
2214 2217 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2215 2218
2216 2219 # save the line away in case we crash, so the post-mortem handler can
2217 2220 # record it
2218 2221 self._last_input_line = line
2219 2222
2220 2223 #print '***line: <%s>' % line # dbg
2221 2224
2222 2225 if not line:
2223 2226 # Return immediately on purely empty lines, so that if the user
2224 2227 # previously typed some whitespace that started a continuation
2225 2228 # prompt, he can break out of that loop with just an empty line.
2226 2229 # This is how the default python prompt works.
2227 2230
2228 2231 # Only return if the accumulated input buffer was just whitespace!
2229 2232 if ''.join(self.buffer).isspace():
2230 2233 self.buffer[:] = []
2231 2234 return ''
2232 2235
2233 2236 line_info = prefilter.LineInfo(line, continue_prompt)
2234 2237
2235 2238 # the input history needs to track even empty lines
2236 2239 stripped = line.strip()
2237 2240
2238 2241 if not stripped:
2239 2242 if not continue_prompt:
2240 2243 self.outputcache.prompt_count -= 1
2241 2244 return self.handle_normal(line_info)
2242 2245
2243 2246 # print '***cont',continue_prompt # dbg
2244 2247 # special handlers are only allowed for single line statements
2245 2248 if continue_prompt and not self.rc.multi_line_specials:
2246 2249 return self.handle_normal(line_info)
2247 2250
2248 2251
2249 2252 # See whether any pre-existing handler can take care of it
2250 2253 rewritten = self.hooks.input_prefilter(stripped)
2251 2254 if rewritten != stripped: # ok, some prefilter did something
2252 2255 rewritten = line_info.pre + rewritten # add indentation
2253 2256 return self.handle_normal(prefilter.LineInfo(rewritten,
2254 2257 continue_prompt))
2255 2258
2256 2259 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2257 2260
2258 2261 return prefilter.prefilter(line_info, self)
2259 2262
2260 2263
2261 2264 def _prefilter_dumb(self, line, continue_prompt):
2262 2265 """simple prefilter function, for debugging"""
2263 2266 return self.handle_normal(line,continue_prompt)
2264 2267
2265 2268
2266 2269 def multiline_prefilter(self, line, continue_prompt):
2267 2270 """ Run _prefilter for each line of input
2268 2271
2269 2272 Covers cases where there are multiple lines in the user entry,
2270 2273 which is the case when the user goes back to a multiline history
2271 2274 entry and presses enter.
2272 2275
2273 2276 """
2274 2277 out = []
2275 2278 for l in line.rstrip('\n').split('\n'):
2276 2279 out.append(self._prefilter(l, continue_prompt))
2277 2280 return '\n'.join(out)
2278 2281
2279 2282 # Set the default prefilter() function (this can be user-overridden)
2280 2283 prefilter = multiline_prefilter
2281 2284
2282 2285 def handle_normal(self,line_info):
2283 2286 """Handle normal input lines. Use as a template for handlers."""
2284 2287
2285 2288 # With autoindent on, we need some way to exit the input loop, and I
2286 2289 # don't want to force the user to have to backspace all the way to
2287 2290 # clear the line. The rule will be in this case, that either two
2288 2291 # lines of pure whitespace in a row, or a line of pure whitespace but
2289 2292 # of a size different to the indent level, will exit the input loop.
2290 2293 line = line_info.line
2291 2294 continue_prompt = line_info.continue_prompt
2292 2295
2293 2296 if (continue_prompt and self.autoindent and line.isspace() and
2294 2297 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2295 2298 (self.buffer[-1]).isspace() )):
2296 2299 line = ''
2297 2300
2298 2301 self.log(line,line,continue_prompt)
2299 2302 return line
2300 2303
2301 2304 def handle_alias(self,line_info):
2302 2305 """Handle alias input lines. """
2303 2306 tgt = self.alias_table[line_info.iFun]
2304 2307 # print "=>",tgt #dbg
2305 2308 if callable(tgt):
2306 2309 if '$' in line_info.line:
2307 2310 call_meth = '(_ip, _ip.itpl(%s))'
2308 2311 else:
2309 2312 call_meth = '(_ip,%s)'
2310 2313 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2311 2314 line_info.iFun,
2312 2315 make_quoted_expr(line_info.line))
2313 2316 else:
2314 2317 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2315 2318
2316 2319 # pre is needed, because it carries the leading whitespace. Otherwise
2317 2320 # aliases won't work in indented sections.
2318 2321 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2319 2322 make_quoted_expr( transformed ))
2320 2323
2321 2324 self.log(line_info.line,line_out,line_info.continue_prompt)
2322 2325 #print 'line out:',line_out # dbg
2323 2326 return line_out
2324 2327
2325 2328 def handle_shell_escape(self, line_info):
2326 2329 """Execute the line in a shell, empty return value"""
2327 2330 #print 'line in :', `line` # dbg
2328 2331 line = line_info.line
2329 2332 if line.lstrip().startswith('!!'):
2330 2333 # rewrite LineInfo's line, iFun and theRest to properly hold the
2331 2334 # call to %sx and the actual command to be executed, so
2332 2335 # handle_magic can work correctly. Note that this works even if
2333 2336 # the line is indented, so it handles multi_line_specials
2334 2337 # properly.
2335 2338 new_rest = line.lstrip()[2:]
2336 2339 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2337 2340 line_info.iFun = 'sx'
2338 2341 line_info.theRest = new_rest
2339 2342 return self.handle_magic(line_info)
2340 2343 else:
2341 2344 cmd = line.lstrip().lstrip('!')
2342 2345 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2343 2346 make_quoted_expr(cmd))
2344 2347 # update cache/log and return
2345 2348 self.log(line,line_out,line_info.continue_prompt)
2346 2349 return line_out
2347 2350
2348 2351 def handle_magic(self, line_info):
2349 2352 """Execute magic functions."""
2350 2353 iFun = line_info.iFun
2351 2354 theRest = line_info.theRest
2352 2355 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2353 2356 make_quoted_expr(iFun + " " + theRest))
2354 2357 self.log(line_info.line,cmd,line_info.continue_prompt)
2355 2358 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2356 2359 return cmd
2357 2360
2358 2361 def handle_auto(self, line_info):
2359 2362 """Hande lines which can be auto-executed, quoting if requested."""
2360 2363
2361 2364 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2362 2365 line = line_info.line
2363 2366 iFun = line_info.iFun
2364 2367 theRest = line_info.theRest
2365 2368 pre = line_info.pre
2366 2369 continue_prompt = line_info.continue_prompt
2367 2370 obj = line_info.ofind(self)['obj']
2368 2371
2369 2372 # This should only be active for single-line input!
2370 2373 if continue_prompt:
2371 2374 self.log(line,line,continue_prompt)
2372 2375 return line
2373 2376
2374 2377 force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
2375 2378 auto_rewrite = True
2376 2379
2377 2380 if pre == self.ESC_QUOTE:
2378 2381 # Auto-quote splitting on whitespace
2379 2382 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2380 2383 elif pre == self.ESC_QUOTE2:
2381 2384 # Auto-quote whole string
2382 2385 newcmd = '%s("%s")' % (iFun,theRest)
2383 2386 elif pre == self.ESC_PAREN:
2384 2387 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2385 2388 else:
2386 2389 # Auto-paren.
2387 2390 # We only apply it to argument-less calls if the autocall
2388 2391 # parameter is set to 2. We only need to check that autocall is <
2389 2392 # 2, since this function isn't called unless it's at least 1.
2390 2393 if not theRest and (self.rc.autocall < 2) and not force_auto:
2391 2394 newcmd = '%s %s' % (iFun,theRest)
2392 2395 auto_rewrite = False
2393 2396 else:
2394 2397 if not force_auto and theRest.startswith('['):
2395 2398 if hasattr(obj,'__getitem__'):
2396 2399 # Don't autocall in this case: item access for an object
2397 2400 # which is BOTH callable and implements __getitem__.
2398 2401 newcmd = '%s %s' % (iFun,theRest)
2399 2402 auto_rewrite = False
2400 2403 else:
2401 2404 # if the object doesn't support [] access, go ahead and
2402 2405 # autocall
2403 2406 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2404 2407 elif theRest.endswith(';'):
2405 2408 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2406 2409 else:
2407 2410 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2408 2411
2409 2412 if auto_rewrite:
2410 2413 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2411 2414
2412 2415 try:
2413 2416 # plain ascii works better w/ pyreadline, on some machines, so
2414 2417 # we use it and only print uncolored rewrite if we have unicode
2415 2418 rw = str(rw)
2416 2419 print >>Term.cout, rw
2417 2420 except UnicodeEncodeError:
2418 2421 print "-------------->" + newcmd
2419 2422
2420 2423 # log what is now valid Python, not the actual user input (without the
2421 2424 # final newline)
2422 2425 self.log(line,newcmd,continue_prompt)
2423 2426 return newcmd
2424 2427
2425 2428 def handle_help(self, line_info):
2426 2429 """Try to get some help for the object.
2427 2430
2428 2431 obj? or ?obj -> basic information.
2429 2432 obj?? or ??obj -> more details.
2430 2433 """
2431 2434
2432 2435 line = line_info.line
2433 2436 # We need to make sure that we don't process lines which would be
2434 2437 # otherwise valid python, such as "x=1 # what?"
2435 2438 try:
2436 2439 codeop.compile_command(line)
2437 2440 except SyntaxError:
2438 2441 # We should only handle as help stuff which is NOT valid syntax
2439 2442 if line[0]==self.ESC_HELP:
2440 2443 line = line[1:]
2441 2444 elif line[-1]==self.ESC_HELP:
2442 2445 line = line[:-1]
2443 2446 self.log(line,'#?'+line,line_info.continue_prompt)
2444 2447 if line:
2445 2448 #print 'line:<%r>' % line # dbg
2446 2449 self.magic_pinfo(line)
2447 2450 else:
2448 2451 page(self.usage,screen_lines=self.rc.screen_length)
2449 2452 return '' # Empty string is needed here!
2450 2453 except:
2451 2454 # Pass any other exceptions through to the normal handler
2452 2455 return self.handle_normal(line_info)
2453 2456 else:
2454 2457 # If the code compiles ok, we should handle it normally
2455 2458 return self.handle_normal(line_info)
2456 2459
2457 2460 def getapi(self):
2458 2461 """ Get an IPApi object for this shell instance
2459 2462
2460 2463 Getting an IPApi object is always preferable to accessing the shell
2461 2464 directly, but this holds true especially for extensions.
2462 2465
2463 2466 It should always be possible to implement an extension with IPApi
2464 2467 alone. If not, contact maintainer to request an addition.
2465 2468
2466 2469 """
2467 2470 return self.api
2468 2471
2469 2472 def handle_emacs(self, line_info):
2470 2473 """Handle input lines marked by python-mode."""
2471 2474
2472 2475 # Currently, nothing is done. Later more functionality can be added
2473 2476 # here if needed.
2474 2477
2475 2478 # The input cache shouldn't be updated
2476 2479 return line_info.line
2477 2480
2478 2481
2479 2482 def mktempfile(self,data=None):
2480 2483 """Make a new tempfile and return its filename.
2481 2484
2482 2485 This makes a call to tempfile.mktemp, but it registers the created
2483 2486 filename internally so ipython cleans it up at exit time.
2484 2487
2485 2488 Optional inputs:
2486 2489
2487 2490 - data(None): if data is given, it gets written out to the temp file
2488 2491 immediately, and the file is closed again."""
2489 2492
2490 2493 filename = tempfile.mktemp('.py','ipython_edit_')
2491 2494 self.tempfiles.append(filename)
2492 2495
2493 2496 if data:
2494 2497 tmp_file = open(filename,'w')
2495 2498 tmp_file.write(data)
2496 2499 tmp_file.close()
2497 2500 return filename
2498 2501
2499 2502 def write(self,data):
2500 2503 """Write a string to the default output"""
2501 2504 Term.cout.write(data)
2502 2505
2503 2506 def write_err(self,data):
2504 2507 """Write a string to the default error output"""
2505 2508 Term.cerr.write(data)
2506 2509
2507 2510 def exit(self):
2508 2511 """Handle interactive exit.
2509 2512
2510 2513 This method sets the exit_now attribute."""
2511 2514
2512 2515 if self.rc.confirm_exit:
2513 2516 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2514 2517 self.exit_now = True
2515 2518 else:
2516 2519 self.exit_now = True
2517 2520
2518 2521 def safe_execfile(self,fname,*where,**kw):
2519 2522 """A safe version of the builtin execfile().
2520 2523
2521 2524 This version will never throw an exception, and knows how to handle
2522 2525 ipython logs as well.
2523 2526
2524 2527 :Parameters:
2525 2528 fname : string
2526 2529 Name of the file to be executed.
2527 2530
2528 2531 where : tuple
2529 2532 One or two namespaces, passed to execfile() as (globals,locals).
2530 2533 If only one is given, it is passed as both.
2531 2534
2532 2535 :Keywords:
2533 2536 islog : boolean (False)
2534 2537
2535 2538 quiet : boolean (True)
2536 2539
2537 2540 exit_ignore : boolean (False)
2538 2541 """
2539 2542
2540 2543 def syspath_cleanup():
2541 2544 """Internal cleanup routine for sys.path."""
2542 2545 if add_dname:
2543 2546 try:
2544 2547 sys.path.remove(dname)
2545 2548 except ValueError:
2546 2549 # For some reason the user has already removed it, ignore.
2547 2550 pass
2548 2551
2549 2552 fname = os.path.expanduser(fname)
2550 2553
2551 2554 # Find things also in current directory. This is needed to mimic the
2552 2555 # behavior of running a script from the system command line, where
2553 2556 # Python inserts the script's directory into sys.path
2554 2557 dname = os.path.dirname(os.path.abspath(fname))
2555 2558 add_dname = False
2556 2559 if dname not in sys.path:
2557 2560 sys.path.insert(0,dname)
2558 2561 add_dname = True
2559 2562
2560 2563 try:
2561 2564 xfile = open(fname)
2562 2565 except:
2563 2566 print >> Term.cerr, \
2564 2567 'Could not open file <%s> for safe execution.' % fname
2565 2568 syspath_cleanup()
2566 2569 return None
2567 2570
2568 2571 kw.setdefault('islog',0)
2569 2572 kw.setdefault('quiet',1)
2570 2573 kw.setdefault('exit_ignore',0)
2571 2574
2572 2575 first = xfile.readline()
2573 2576 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2574 2577 xfile.close()
2575 2578 # line by line execution
2576 2579 if first.startswith(loghead) or kw['islog']:
2577 2580 print 'Loading log file <%s> one line at a time...' % fname
2578 2581 if kw['quiet']:
2579 2582 stdout_save = sys.stdout
2580 2583 sys.stdout = StringIO.StringIO()
2581 2584 try:
2582 2585 globs,locs = where[0:2]
2583 2586 except:
2584 2587 try:
2585 2588 globs = locs = where[0]
2586 2589 except:
2587 2590 globs = locs = globals()
2588 2591 badblocks = []
2589 2592
2590 2593 # we also need to identify indented blocks of code when replaying
2591 2594 # logs and put them together before passing them to an exec
2592 2595 # statement. This takes a bit of regexp and look-ahead work in the
2593 2596 # file. It's easiest if we swallow the whole thing in memory
2594 2597 # first, and manually walk through the lines list moving the
2595 2598 # counter ourselves.
2596 2599 indent_re = re.compile('\s+\S')
2597 2600 xfile = open(fname)
2598 2601 filelines = xfile.readlines()
2599 2602 xfile.close()
2600 2603 nlines = len(filelines)
2601 2604 lnum = 0
2602 2605 while lnum < nlines:
2603 2606 line = filelines[lnum]
2604 2607 lnum += 1
2605 2608 # don't re-insert logger status info into cache
2606 2609 if line.startswith('#log#'):
2607 2610 continue
2608 2611 else:
2609 2612 # build a block of code (maybe a single line) for execution
2610 2613 block = line
2611 2614 try:
2612 2615 next = filelines[lnum] # lnum has already incremented
2613 2616 except:
2614 2617 next = None
2615 2618 while next and indent_re.match(next):
2616 2619 block += next
2617 2620 lnum += 1
2618 2621 try:
2619 2622 next = filelines[lnum]
2620 2623 except:
2621 2624 next = None
2622 2625 # now execute the block of one or more lines
2623 2626 try:
2624 2627 exec block in globs,locs
2625 2628 except SystemExit:
2626 2629 pass
2627 2630 except:
2628 2631 badblocks.append(block.rstrip())
2629 2632 if kw['quiet']: # restore stdout
2630 2633 sys.stdout.close()
2631 2634 sys.stdout = stdout_save
2632 2635 print 'Finished replaying log file <%s>' % fname
2633 2636 if badblocks:
2634 2637 print >> sys.stderr, ('\nThe following lines/blocks in file '
2635 2638 '<%s> reported errors:' % fname)
2636 2639
2637 2640 for badline in badblocks:
2638 2641 print >> sys.stderr, badline
2639 2642 else: # regular file execution
2640 2643 try:
2641 2644 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2642 2645 # Work around a bug in Python for Windows. The bug was
2643 2646 # fixed in in Python 2.5 r54159 and 54158, but that's still
2644 2647 # SVN Python as of March/07. For details, see:
2645 2648 # http://projects.scipy.org/ipython/ipython/ticket/123
2646 2649 try:
2647 2650 globs,locs = where[0:2]
2648 2651 except:
2649 2652 try:
2650 2653 globs = locs = where[0]
2651 2654 except:
2652 2655 globs = locs = globals()
2653 2656 exec file(fname) in globs,locs
2654 2657 else:
2655 2658 execfile(fname,*where)
2656 2659 except SyntaxError:
2657 2660 self.showsyntaxerror()
2658 2661 warn('Failure executing file: <%s>' % fname)
2659 2662 except SystemExit,status:
2660 2663 # Code that correctly sets the exit status flag to success (0)
2661 2664 # shouldn't be bothered with a traceback. Note that a plain
2662 2665 # sys.exit() does NOT set the message to 0 (it's empty) so that
2663 2666 # will still get a traceback. Note that the structure of the
2664 2667 # SystemExit exception changed between Python 2.4 and 2.5, so
2665 2668 # the checks must be done in a version-dependent way.
2666 2669 show = False
2667 2670
2668 2671 if sys.version_info[:2] > (2,5):
2669 2672 if status.message!=0 and not kw['exit_ignore']:
2670 2673 show = True
2671 2674 else:
2672 2675 if status.code and not kw['exit_ignore']:
2673 2676 show = True
2674 2677 if show:
2675 2678 self.showtraceback()
2676 2679 warn('Failure executing file: <%s>' % fname)
2677 2680 except:
2678 2681 self.showtraceback()
2679 2682 warn('Failure executing file: <%s>' % fname)
2680 2683
2681 2684 syspath_cleanup()
2682 2685
2683 2686 #************************* end of file <iplib.py> *****************************
@@ -1,775 +1,778 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 IPython -- An enhanced Interactive Python
4 4
5 5 Requires Python 2.1 or better.
6 6
7 7 This file contains the main make_IPython() starter function.
8 8
9 9 $Id: ipmaker.py 2930 2008-01-11 07:03:11Z vivainio $"""
10 10
11 11 #*****************************************************************************
12 12 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
13 13 #
14 14 # Distributed under the terms of the BSD License. The full license is in
15 15 # the file COPYING, distributed as part of this software.
16 16 #*****************************************************************************
17 17
18 18 from IPython import Release
19 19 __author__ = '%s <%s>' % Release.authors['Fernando']
20 20 __license__ = Release.license
21 21 __version__ = Release.version
22 22
23 23 try:
24 24 credits._Printer__data = """
25 25 Python: %s
26 26
27 27 IPython: Fernando Perez, Janko Hauser, Nathan Gray, and many users.
28 28 See http://ipython.scipy.org for more information.""" \
29 29 % credits._Printer__data
30 30
31 31 copyright._Printer__data += """
32 32
33 33 Copyright (c) 2001-2004 Fernando Perez, Janko Hauser, Nathan Gray.
34 34 All Rights Reserved."""
35 35 except NameError:
36 36 # Can happen if ipython was started with 'python -S', so that site.py is
37 37 # not loaded
38 38 pass
39 39
40 40 #****************************************************************************
41 41 # Required modules
42 42
43 43 # From the standard library
44 44 import __main__
45 45 import __builtin__
46 46 import os
47 47 import re
48 48 import sys
49 49 import types
50 50 from pprint import pprint,pformat
51 51
52 52 # Our own
53 53 from IPython import DPyGetOpt
54 54 from IPython.ipstruct import Struct
55 55 from IPython.OutputTrap import OutputTrap
56 56 from IPython.ConfigLoader import ConfigLoader
57 57 from IPython.iplib import InteractiveShell
58 58 from IPython.usage import cmd_line_usage,interactive_usage
59 59 from IPython.genutils import *
60 60
61 61 def force_import(modname):
62 62 if modname in sys.modules:
63 63 print "reload",modname
64 64 reload(sys.modules[modname])
65 65 else:
66 66 __import__(modname)
67 67
68 68
69 69 #-----------------------------------------------------------------------------
70 70 def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,
71 71 rc_override=None,shell_class=InteractiveShell,
72 72 embedded=False,**kw):
73 73 """This is a dump of IPython into a single function.
74 74
75 75 Later it will have to be broken up in a sensible manner.
76 76
77 77 Arguments:
78 78
79 79 - argv: a list similar to sys.argv[1:]. It should NOT contain the desired
80 80 script name, b/c DPyGetOpt strips the first argument only for the real
81 81 sys.argv.
82 82
83 83 - user_ns: a dict to be used as the user's namespace."""
84 84
85 85 #----------------------------------------------------------------------
86 86 # Defaults and initialization
87 87
88 88 # For developer debugging, deactivates crash handler and uses pdb.
89 89 DEVDEBUG = False
90 90
91 91 if argv is None:
92 92 argv = sys.argv
93 93
94 94 # __IP is the main global that lives throughout and represents the whole
95 95 # application. If the user redefines it, all bets are off as to what
96 96 # happens.
97 97
98 98 # __IP is the name of he global which the caller will have accessible as
99 99 # __IP.name. We set its name via the first parameter passed to
100 100 # InteractiveShell:
101 101
102 102 IP = shell_class('__IP',user_ns=user_ns,user_global_ns=user_global_ns,
103 103 embedded=embedded,**kw)
104 104
105 105 # Put 'help' in the user namespace
106 from site import _Helper
106 try:
107 from site import _Helper
108 IP.user_ns['help'] = _Helper()
109 except ImportError:
110 warn('help() not available - check site.py')
107 111 IP.user_config_ns = {}
108 IP.user_ns['help'] = _Helper()
109 112
110 113
111 114 if DEVDEBUG:
112 115 # For developer debugging only (global flag)
113 116 from IPython import ultraTB
114 117 sys.excepthook = ultraTB.VerboseTB(call_pdb=1)
115 118
116 119 IP.BANNER_PARTS = ['Python %s\n'
117 120 'Type "copyright", "credits" or "license" '
118 121 'for more information.\n'
119 122 % (sys.version.split('\n')[0],),
120 123 "IPython %s -- An enhanced Interactive Python."
121 124 % (__version__,),
122 125 """\
123 126 ? -> Introduction and overview of IPython's features.
124 127 %quickref -> Quick reference.
125 128 help -> Python's own help system.
126 129 object? -> Details about 'object'. ?object also works, ?? prints more.
127 130 """ ]
128 131
129 132 IP.usage = interactive_usage
130 133
131 134 # Platform-dependent suffix and directory names. We use _ipython instead
132 135 # of .ipython under win32 b/c there's software that breaks with .named
133 136 # directories on that platform.
134 137 if os.name == 'posix':
135 138 rc_suffix = ''
136 139 ipdir_def = '.ipython'
137 140 else:
138 141 rc_suffix = '.ini'
139 142 ipdir_def = '_ipython'
140 143
141 144 # default directory for configuration
142 145 ipythondir_def = os.path.abspath(os.environ.get('IPYTHONDIR',
143 146 os.path.join(IP.home_dir,ipdir_def)))
144 147
145 148 sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
146 149
147 150 # we need the directory where IPython itself is installed
148 151 import IPython
149 152 IPython_dir = os.path.dirname(IPython.__file__)
150 153 del IPython
151 154
152 155 #-------------------------------------------------------------------------
153 156 # Command line handling
154 157
155 158 # Valid command line options (uses DPyGetOpt syntax, like Perl's
156 159 # GetOpt::Long)
157 160
158 161 # Any key not listed here gets deleted even if in the file (like session
159 162 # or profile). That's deliberate, to maintain the rc namespace clean.
160 163
161 164 # Each set of options appears twice: under _conv only the names are
162 165 # listed, indicating which type they must be converted to when reading the
163 166 # ipythonrc file. And under DPyGetOpt they are listed with the regular
164 167 # DPyGetOpt syntax (=s,=i,:f,etc).
165 168
166 169 # Make sure there's a space before each end of line (they get auto-joined!)
167 170 cmdline_opts = ('autocall=i autoindent! automagic! banner! cache_size|cs=i '
168 171 'c=s classic|cl color_info! colors=s confirm_exit! '
169 172 'debug! deep_reload! editor=s log|l messages! nosep '
170 173 'object_info_string_level=i pdb! '
171 174 'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s '
172 175 'pydb! '
173 176 'pylab_import_all! '
174 177 'quick screen_length|sl=i prompts_pad_left=i '
175 178 'logfile|lf=s logplay|lp=s profile|p=s '
176 179 'readline! readline_merge_completions! '
177 180 'readline_omit__names! '
178 181 'rcfile=s separate_in|si=s separate_out|so=s '
179 182 'separate_out2|so2=s xmode=s wildcards_case_sensitive! '
180 183 'magic_docstrings system_verbose! '
181 184 'multi_line_specials! '
182 185 'term_title! wxversion=s '
183 186 'autoedit_syntax!')
184 187
185 188 # Options that can *only* appear at the cmd line (not in rcfiles).
186 189
187 190 cmdline_only = ('help interact|i ipythondir=s Version upgrade '
188 191 'gthread! qthread! q4thread! wthread! tkthread! pylab! tk! '
189 192 'twisted!')
190 193
191 194 # Build the actual name list to be used by DPyGetOpt
192 195 opts_names = qw(cmdline_opts) + qw(cmdline_only)
193 196
194 197 # Set sensible command line defaults.
195 198 # This should have everything from cmdline_opts and cmdline_only
196 199 opts_def = Struct(autocall = 1,
197 200 autoedit_syntax = 0,
198 201 autoindent = 0,
199 202 automagic = 1,
200 203 autoexec = [],
201 204 banner = 1,
202 205 c = '',
203 206 cache_size = 1000,
204 207 classic = 0,
205 208 color_info = 0,
206 209 colors = 'NoColor',
207 210 confirm_exit = 1,
208 211 debug = 0,
209 212 deep_reload = 0,
210 213 editor = '0',
211 214 gthread = 0,
212 215 help = 0,
213 216 interact = 0,
214 217 ipythondir = ipythondir_def,
215 218 log = 0,
216 219 logfile = '',
217 220 logplay = '',
218 221 messages = 1,
219 222 multi_line_specials = 1,
220 223 nosep = 0,
221 224 object_info_string_level = 0,
222 225 pdb = 0,
223 226 pprint = 0,
224 227 profile = '',
225 228 prompt_in1 = 'In [\\#]: ',
226 229 prompt_in2 = ' .\\D.: ',
227 230 prompt_out = 'Out[\\#]: ',
228 231 prompts_pad_left = 1,
229 232 pylab = 0,
230 233 pylab_import_all = 1,
231 234 q4thread = 0,
232 235 qthread = 0,
233 236 quick = 0,
234 237 quiet = 0,
235 238 rcfile = 'ipythonrc' + rc_suffix,
236 239 readline = 1,
237 240 readline_merge_completions = 1,
238 241 readline_omit__names = 0,
239 242 screen_length = 0,
240 243 separate_in = '\n',
241 244 separate_out = '\n',
242 245 separate_out2 = '',
243 246 system_header = 'IPython system call: ',
244 247 system_verbose = 0,
245 248 term_title = 1,
246 249 tk = 0,
247 250 twisted= 0,
248 251 upgrade = 0,
249 252 Version = 0,
250 253 wildcards_case_sensitive = 1,
251 254 wthread = 0,
252 255 wxversion = '0',
253 256 xmode = 'Context',
254 257 magic_docstrings = 0, # undocumented, for doc generation
255 258 )
256 259
257 260 # Things that will *only* appear in rcfiles (not at the command line).
258 261 # Make sure there's a space before each end of line (they get auto-joined!)
259 262 rcfile_opts = { qwflat: 'include import_mod import_all execfile ',
260 263 qw_lol: 'import_some ',
261 264 # for things with embedded whitespace:
262 265 list_strings:'execute alias readline_parse_and_bind ',
263 266 # Regular strings need no conversion:
264 267 None:'readline_remove_delims ',
265 268 }
266 269 # Default values for these
267 270 rc_def = Struct(include = [],
268 271 import_mod = [],
269 272 import_all = [],
270 273 import_some = [[]],
271 274 execute = [],
272 275 execfile = [],
273 276 alias = [],
274 277 readline_parse_and_bind = [],
275 278 readline_remove_delims = '',
276 279 )
277 280
278 281 # Build the type conversion dictionary from the above tables:
279 282 typeconv = rcfile_opts.copy()
280 283 typeconv.update(optstr2types(cmdline_opts))
281 284
282 285 # FIXME: the None key appears in both, put that back together by hand. Ugly!
283 286 typeconv[None] += ' ' + rcfile_opts[None]
284 287
285 288 # Remove quotes at ends of all strings (used to protect spaces)
286 289 typeconv[unquote_ends] = typeconv[None]
287 290 del typeconv[None]
288 291
289 292 # Build the list we'll use to make all config decisions with defaults:
290 293 opts_all = opts_def.copy()
291 294 opts_all.update(rc_def)
292 295
293 296 # Build conflict resolver for recursive loading of config files:
294 297 # - preserve means the outermost file maintains the value, it is not
295 298 # overwritten if an included file has the same key.
296 299 # - add_flip applies + to the two values, so it better make sense to add
297 300 # those types of keys. But it flips them first so that things loaded
298 301 # deeper in the inclusion chain have lower precedence.
299 302 conflict = {'preserve': ' '.join([ typeconv[int],
300 303 typeconv[unquote_ends] ]),
301 304 'add_flip': ' '.join([ typeconv[qwflat],
302 305 typeconv[qw_lol],
303 306 typeconv[list_strings] ])
304 307 }
305 308
306 309 # Now actually process the command line
307 310 getopt = DPyGetOpt.DPyGetOpt()
308 311 getopt.setIgnoreCase(0)
309 312
310 313 getopt.parseConfiguration(opts_names)
311 314
312 315 try:
313 316 getopt.processArguments(argv)
314 317 except DPyGetOpt.ArgumentError, exc:
315 318 print cmd_line_usage
316 319 warn('\nError in Arguments: "%s"' % exc)
317 320 sys.exit(1)
318 321
319 322 # convert the options dict to a struct for much lighter syntax later
320 323 opts = Struct(getopt.optionValues)
321 324 args = getopt.freeValues
322 325
323 326 # this is the struct (which has default values at this point) with which
324 327 # we make all decisions:
325 328 opts_all.update(opts)
326 329
327 330 # Options that force an immediate exit
328 331 if opts_all.help:
329 332 page(cmd_line_usage)
330 333 sys.exit()
331 334
332 335 if opts_all.Version:
333 336 print __version__
334 337 sys.exit()
335 338
336 339 if opts_all.magic_docstrings:
337 340 IP.magic_magic('-latex')
338 341 sys.exit()
339 342
340 343 # add personal ipythondir to sys.path so that users can put things in
341 344 # there for customization
342 345 sys.path.append(os.path.abspath(opts_all.ipythondir))
343 346
344 347 # Create user config directory if it doesn't exist. This must be done
345 348 # *after* getting the cmd line options.
346 349 if not os.path.isdir(opts_all.ipythondir):
347 350 IP.user_setup(opts_all.ipythondir,rc_suffix,'install')
348 351
349 352 # upgrade user config files while preserving a copy of the originals
350 353 if opts_all.upgrade:
351 354 IP.user_setup(opts_all.ipythondir,rc_suffix,'upgrade')
352 355
353 356 # check mutually exclusive options in the *original* command line
354 357 mutex_opts(opts,[qw('log logfile'),qw('rcfile profile'),
355 358 qw('classic profile'),qw('classic rcfile')])
356 359
357 360 #---------------------------------------------------------------------------
358 361 # Log replay
359 362
360 363 # if -logplay, we need to 'become' the other session. That basically means
361 364 # replacing the current command line environment with that of the old
362 365 # session and moving on.
363 366
364 367 # this is needed so that later we know we're in session reload mode, as
365 368 # opts_all will get overwritten:
366 369 load_logplay = 0
367 370
368 371 if opts_all.logplay:
369 372 load_logplay = opts_all.logplay
370 373 opts_debug_save = opts_all.debug
371 374 try:
372 375 logplay = open(opts_all.logplay)
373 376 except IOError:
374 377 if opts_all.debug: IP.InteractiveTB()
375 378 warn('Could not open logplay file '+`opts_all.logplay`)
376 379 # restore state as if nothing had happened and move on, but make
377 380 # sure that later we don't try to actually load the session file
378 381 logplay = None
379 382 load_logplay = 0
380 383 del opts_all.logplay
381 384 else:
382 385 try:
383 386 logplay.readline()
384 387 logplay.readline();
385 388 # this reloads that session's command line
386 389 cmd = logplay.readline()[6:]
387 390 exec cmd
388 391 # restore the true debug flag given so that the process of
389 392 # session loading itself can be monitored.
390 393 opts.debug = opts_debug_save
391 394 # save the logplay flag so later we don't overwrite the log
392 395 opts.logplay = load_logplay
393 396 # now we must update our own structure with defaults
394 397 opts_all.update(opts)
395 398 # now load args
396 399 cmd = logplay.readline()[6:]
397 400 exec cmd
398 401 logplay.close()
399 402 except:
400 403 logplay.close()
401 404 if opts_all.debug: IP.InteractiveTB()
402 405 warn("Logplay file lacking full configuration information.\n"
403 406 "I'll try to read it, but some things may not work.")
404 407
405 408 #-------------------------------------------------------------------------
406 409 # set up output traps: catch all output from files, being run, modules
407 410 # loaded, etc. Then give it to the user in a clean form at the end.
408 411
409 412 msg_out = 'Output messages. '
410 413 msg_err = 'Error messages. '
411 414 msg_sep = '\n'
412 415 msg = Struct(config = OutputTrap('Configuration Loader',msg_out,
413 416 msg_err,msg_sep,debug,
414 417 quiet_out=1),
415 418 user_exec = OutputTrap('User File Execution',msg_out,
416 419 msg_err,msg_sep,debug),
417 420 logplay = OutputTrap('Log Loader',msg_out,
418 421 msg_err,msg_sep,debug),
419 422 summary = ''
420 423 )
421 424
422 425 #-------------------------------------------------------------------------
423 426 # Process user ipythonrc-type configuration files
424 427
425 428 # turn on output trapping and log to msg.config
426 429 # remember that with debug on, trapping is actually disabled
427 430 msg.config.trap_all()
428 431
429 432 # look for rcfile in current or default directory
430 433 try:
431 434 opts_all.rcfile = filefind(opts_all.rcfile,opts_all.ipythondir)
432 435 except IOError:
433 436 if opts_all.debug: IP.InteractiveTB()
434 437 warn('Configuration file %s not found. Ignoring request.'
435 438 % (opts_all.rcfile) )
436 439
437 440 # 'profiles' are a shorthand notation for config filenames
438 441 profile_handled_by_legacy = False
439 442 if opts_all.profile:
440 443
441 444 try:
442 445 opts_all.rcfile = filefind('ipythonrc-' + opts_all.profile
443 446 + rc_suffix,
444 447 opts_all.ipythondir)
445 448 profile_handled_by_legacy = True
446 449 except IOError:
447 450 if opts_all.debug: IP.InteractiveTB()
448 451 opts.profile = '' # remove profile from options if invalid
449 452 # We won't warn anymore, primary method is ipy_profile_PROFNAME
450 453 # which does trigger a warning.
451 454
452 455 # load the config file
453 456 rcfiledata = None
454 457 if opts_all.quick:
455 458 print 'Launching IPython in quick mode. No config file read.'
456 459 elif opts_all.rcfile:
457 460 try:
458 461 cfg_loader = ConfigLoader(conflict)
459 462 rcfiledata = cfg_loader.load(opts_all.rcfile,typeconv,
460 463 'include',opts_all.ipythondir,
461 464 purge = 1,
462 465 unique = conflict['preserve'])
463 466 except:
464 467 IP.InteractiveTB()
465 468 warn('Problems loading configuration file '+
466 469 `opts_all.rcfile`+
467 470 '\nStarting with default -bare bones- configuration.')
468 471 else:
469 472 warn('No valid configuration file found in either currrent directory\n'+
470 473 'or in the IPython config. directory: '+`opts_all.ipythondir`+
471 474 '\nProceeding with internal defaults.')
472 475
473 476 #------------------------------------------------------------------------
474 477 # Set exception handlers in mode requested by user.
475 478 otrap = OutputTrap(trap_out=1) # trap messages from magic_xmode
476 479 IP.magic_xmode(opts_all.xmode)
477 480 otrap.release_out()
478 481
479 482 #------------------------------------------------------------------------
480 483 # Execute user config
481 484
482 485 # Create a valid config structure with the right precedence order:
483 486 # defaults < rcfile < command line. This needs to be in the instance, so
484 487 # that method calls below that rely on it find it.
485 488 IP.rc = rc_def.copy()
486 489
487 490 # Work with a local alias inside this routine to avoid unnecessary
488 491 # attribute lookups.
489 492 IP_rc = IP.rc
490 493
491 494 IP_rc.update(opts_def)
492 495 if rcfiledata:
493 496 # now we can update
494 497 IP_rc.update(rcfiledata)
495 498 IP_rc.update(opts)
496 499 IP_rc.update(rc_override)
497 500
498 501 # Store the original cmd line for reference:
499 502 IP_rc.opts = opts
500 503 IP_rc.args = args
501 504
502 505 # create a *runtime* Struct like rc for holding parameters which may be
503 506 # created and/or modified by runtime user extensions.
504 507 IP.runtime_rc = Struct()
505 508
506 509 # from this point on, all config should be handled through IP_rc,
507 510 # opts* shouldn't be used anymore.
508 511
509 512
510 513 # update IP_rc with some special things that need manual
511 514 # tweaks. Basically options which affect other options. I guess this
512 515 # should just be written so that options are fully orthogonal and we
513 516 # wouldn't worry about this stuff!
514 517
515 518 if IP_rc.classic:
516 519 IP_rc.quick = 1
517 520 IP_rc.cache_size = 0
518 521 IP_rc.pprint = 0
519 522 IP_rc.prompt_in1 = '>>> '
520 523 IP_rc.prompt_in2 = '... '
521 524 IP_rc.prompt_out = ''
522 525 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
523 526 IP_rc.colors = 'NoColor'
524 527 IP_rc.xmode = 'Plain'
525 528
526 529 IP.pre_config_initialization()
527 530 # configure readline
528 531 # Define the history file for saving commands in between sessions
529 532 if IP_rc.profile:
530 533 histfname = 'history-%s' % IP_rc.profile
531 534 else:
532 535 histfname = 'history'
533 536 IP.histfile = os.path.join(opts_all.ipythondir,histfname)
534 537
535 538 # update exception handlers with rc file status
536 539 otrap.trap_out() # I don't want these messages ever.
537 540 IP.magic_xmode(IP_rc.xmode)
538 541 otrap.release_out()
539 542
540 543 # activate logging if requested and not reloading a log
541 544 if IP_rc.logplay:
542 545 IP.magic_logstart(IP_rc.logplay + ' append')
543 546 elif IP_rc.logfile:
544 547 IP.magic_logstart(IP_rc.logfile)
545 548 elif IP_rc.log:
546 549 IP.magic_logstart()
547 550
548 551 # find user editor so that it we don't have to look it up constantly
549 552 if IP_rc.editor.strip()=='0':
550 553 try:
551 554 ed = os.environ['EDITOR']
552 555 except KeyError:
553 556 if os.name == 'posix':
554 557 ed = 'vi' # the only one guaranteed to be there!
555 558 else:
556 559 ed = 'notepad' # same in Windows!
557 560 IP_rc.editor = ed
558 561
559 562 # Keep track of whether this is an embedded instance or not (useful for
560 563 # post-mortems).
561 564 IP_rc.embedded = IP.embedded
562 565
563 566 # Recursive reload
564 567 try:
565 568 from IPython import deep_reload
566 569 if IP_rc.deep_reload:
567 570 __builtin__.reload = deep_reload.reload
568 571 else:
569 572 __builtin__.dreload = deep_reload.reload
570 573 del deep_reload
571 574 except ImportError:
572 575 pass
573 576
574 577 # Save the current state of our namespace so that the interactive shell
575 578 # can later know which variables have been created by us from config files
576 579 # and loading. This way, loading a file (in any way) is treated just like
577 580 # defining things on the command line, and %who works as expected.
578 581
579 582 # DON'T do anything that affects the namespace beyond this point!
580 583 IP.internal_ns.update(__main__.__dict__)
581 584
582 585 #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who
583 586
584 587 # Now run through the different sections of the users's config
585 588 if IP_rc.debug:
586 589 print 'Trying to execute the following configuration structure:'
587 590 print '(Things listed first are deeper in the inclusion tree and get'
588 591 print 'loaded first).\n'
589 592 pprint(IP_rc.__dict__)
590 593
591 594 for mod in IP_rc.import_mod:
592 595 try:
593 596 exec 'import '+mod in IP.user_ns
594 597 except :
595 598 IP.InteractiveTB()
596 599 import_fail_info(mod)
597 600
598 601 for mod_fn in IP_rc.import_some:
599 602 if not mod_fn == []:
600 603 mod,fn = mod_fn[0],','.join(mod_fn[1:])
601 604 try:
602 605 exec 'from '+mod+' import '+fn in IP.user_ns
603 606 except :
604 607 IP.InteractiveTB()
605 608 import_fail_info(mod,fn)
606 609
607 610 for mod in IP_rc.import_all:
608 611 try:
609 612 exec 'from '+mod+' import *' in IP.user_ns
610 613 except :
611 614 IP.InteractiveTB()
612 615 import_fail_info(mod)
613 616
614 617 for code in IP_rc.execute:
615 618 try:
616 619 exec code in IP.user_ns
617 620 except:
618 621 IP.InteractiveTB()
619 622 warn('Failure executing code: ' + `code`)
620 623
621 624 # Execute the files the user wants in ipythonrc
622 625 for file in IP_rc.execfile:
623 626 try:
624 627 file = filefind(file,sys.path+[IPython_dir])
625 628 except IOError:
626 629 warn(itpl('File $file not found. Skipping it.'))
627 630 else:
628 631 IP.safe_execfile(os.path.expanduser(file),IP.user_ns)
629 632
630 633 # finally, try importing ipy_*_conf for final configuration
631 634 try:
632 635 import ipy_system_conf
633 636 except ImportError:
634 637 if opts_all.debug: IP.InteractiveTB()
635 638 warn("Could not import 'ipy_system_conf'")
636 639 except:
637 640 IP.InteractiveTB()
638 641 import_fail_info('ipy_system_conf')
639 642
640 643 # only import prof module if ipythonrc-PROF was not found
641 644 if opts_all.profile and not profile_handled_by_legacy:
642 645 profmodname = 'ipy_profile_' + opts_all.profile
643 646 try:
644 647
645 648 force_import(profmodname)
646 649 except:
647 650 IP.InteractiveTB()
648 651 print "Error importing",profmodname,"- perhaps you should run %upgrade?"
649 652 import_fail_info(profmodname)
650 653 else:
651 654 force_import('ipy_profile_none')
652 655 try:
653 656
654 657 force_import('ipy_user_conf')
655 658
656 659 except:
657 660 conf = opts_all.ipythondir + "/ipy_user_conf.py"
658 661 IP.InteractiveTB()
659 662 if not os.path.isfile(conf):
660 663 warn(conf + ' does not exist, please run %upgrade!')
661 664
662 665 import_fail_info("ipy_user_conf")
663 666
664 667 # finally, push the argv to options again to ensure highest priority
665 668 IP_rc.update(opts)
666 669
667 670 # release stdout and stderr and save config log into a global summary
668 671 msg.config.release_all()
669 672 if IP_rc.messages:
670 673 msg.summary += msg.config.summary_all()
671 674
672 675 #------------------------------------------------------------------------
673 676 # Setup interactive session
674 677
675 678 # Now we should be fully configured. We can then execute files or load
676 679 # things only needed for interactive use. Then we'll open the shell.
677 680
678 681 # Take a snapshot of the user namespace before opening the shell. That way
679 682 # we'll be able to identify which things were interactively defined and
680 683 # which were defined through config files.
681 684 IP.user_config_ns.update(IP.user_ns)
682 685
683 686 # Force reading a file as if it were a session log. Slower but safer.
684 687 if load_logplay:
685 688 print 'Replaying log...'
686 689 try:
687 690 if IP_rc.debug:
688 691 logplay_quiet = 0
689 692 else:
690 693 logplay_quiet = 1
691 694
692 695 msg.logplay.trap_all()
693 696 IP.safe_execfile(load_logplay,IP.user_ns,
694 697 islog = 1, quiet = logplay_quiet)
695 698 msg.logplay.release_all()
696 699 if IP_rc.messages:
697 700 msg.summary += msg.logplay.summary_all()
698 701 except:
699 702 warn('Problems replaying logfile %s.' % load_logplay)
700 703 IP.InteractiveTB()
701 704
702 705 # Load remaining files in command line
703 706 msg.user_exec.trap_all()
704 707
705 708 # Do NOT execute files named in the command line as scripts to be loaded
706 709 # by embedded instances. Doing so has the potential for an infinite
707 710 # recursion if there are exceptions thrown in the process.
708 711
709 712 # XXX FIXME: the execution of user files should be moved out to after
710 713 # ipython is fully initialized, just as if they were run via %run at the
711 714 # ipython prompt. This would also give them the benefit of ipython's
712 715 # nice tracebacks.
713 716
714 717 if (not embedded and IP_rc.args and
715 718 not IP_rc.args[0].lower().endswith('.ipy')):
716 719 name_save = IP.user_ns['__name__']
717 720 IP.user_ns['__name__'] = '__main__'
718 721 # Set our own excepthook in case the user code tries to call it
719 722 # directly. This prevents triggering the IPython crash handler.
720 723 old_excepthook,sys.excepthook = sys.excepthook, IP.excepthook
721 724
722 725 save_argv = sys.argv[1:] # save it for later restoring
723 726
724 727 sys.argv = args
725 728
726 729 try:
727 730 IP.safe_execfile(args[0], IP.user_ns)
728 731 finally:
729 732 # Reset our crash handler in place
730 733 sys.excepthook = old_excepthook
731 734 sys.argv[:] = save_argv
732 735 IP.user_ns['__name__'] = name_save
733 736
734 737 msg.user_exec.release_all()
735 738
736 739 if IP_rc.messages:
737 740 msg.summary += msg.user_exec.summary_all()
738 741
739 742 # since we can't specify a null string on the cmd line, 0 is the equivalent:
740 743 if IP_rc.nosep:
741 744 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
742 745 if IP_rc.separate_in == '0': IP_rc.separate_in = ''
743 746 if IP_rc.separate_out == '0': IP_rc.separate_out = ''
744 747 if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = ''
745 748 IP_rc.separate_in = IP_rc.separate_in.replace('\\n','\n')
746 749 IP_rc.separate_out = IP_rc.separate_out.replace('\\n','\n')
747 750 IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n','\n')
748 751
749 752 # Determine how many lines at the bottom of the screen are needed for
750 753 # showing prompts, so we can know wheter long strings are to be printed or
751 754 # paged:
752 755 num_lines_bot = IP_rc.separate_in.count('\n')+1
753 756 IP_rc.screen_length = IP_rc.screen_length - num_lines_bot
754 757
755 758 # configure startup banner
756 759 if IP_rc.c: # regular python doesn't print the banner with -c
757 760 IP_rc.banner = 0
758 761 if IP_rc.banner:
759 762 BANN_P = IP.BANNER_PARTS
760 763 else:
761 764 BANN_P = []
762 765
763 766 if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile)
764 767
765 768 # add message log (possibly empty)
766 769 if msg.summary: BANN_P.append(msg.summary)
767 770 # Final banner is a string
768 771 IP.BANNER = '\n'.join(BANN_P)
769 772
770 773 # Finalize the IPython instance. This assumes the rc structure is fully
771 774 # in place.
772 775 IP.post_config_initialization()
773 776
774 777 return IP
775 778 #************************ end of file <ipmaker.py> **************************
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: file was removed
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: file was removed
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: file was removed
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now