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