##// END OF EJS Templates
Added platutils modules, now only needed for %cd to ...
vivainio -
Show More

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

@@ -0,0 +1,35 b''
1 # -*- coding: utf-8 -*-
2 """ Proxy module for accessing platform specific utility functions.
3
4 Importing this module should give you the implementations that are correct
5 for your operation system, from platutils_PLATFORMNAME module.
6
7 $Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
8
9
10 """
11
12
13 #*****************************************************************************
14 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
15 #
16 # Distributed under the terms of the BSD License. The full license is in
17 # the file COPYING, distributed as part of this software.
18 #*****************************************************************************
19
20 from IPython import Release
21 __author__ = '%s <%s>' % Release.authors['Ville']
22 __license__ = Release.license
23
24 import os
25
26 if os.name == 'posix':
27 from platutils_posix import *
28 elif os.name == 'win32':
29 from platutils_win32 import *
30 else:
31 from platutils_dummy import *
32 import warnings
33 warnings.warn("Platutils not available for platform '%s', some features may be missing" %
34 os.name)
35 del warnings
@@ -0,0 +1,29 b''
1 # -*- coding: utf-8 -*-
2 """ Platform specific utility functions, dummy version
3
4 This has empty implementation of the platutils functions, used for
5 unsupported operating systems.
6
7 $Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
8
9
10 """
11
12
13 #*****************************************************************************
14 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
15 #
16 # Distributed under the terms of the BSD License. The full license is in
17 # the file COPYING, distributed as part of this software.
18 #*****************************************************************************
19
20 from IPython import Release
21 __author__ = '%s <%s>' % Release.authors['Ville']
22 __license__ = Release.license
23
24
25 def _dummy(*args,**kw):
26 pass
27
28 set_term_title = _dummy
29
@@ -0,0 +1,26 b''
1 # -*- coding: utf-8 -*-
2 """ Platform specific utility functions, posix version
3
4 Importing this module directly is not portable - rather, import platutils
5 to use these functions in platform agnostic fashion.
6
7 $Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
8
9 """
10
11
12 #*****************************************************************************
13 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
14 #
15 # Distributed under the terms of the BSD License. The full license is in
16 # the file COPYING, distributed as part of this software.
17 #*****************************************************************************
18
19 from IPython import Release
20 __author__ = '%s <%s>' % Release.authors['Ville']
21 __license__ = Release.license
22
23 import sys
24
25 def set_term_title(title):
26 sys.stdout.write('\033]%d;%s\007' % (0,title))
@@ -0,0 +1,25 b''
1 # -*- coding: utf-8 -*-
2 """ Platform specific utility functions, win32 version
3
4 Importing this module directly is not portable - rather, import platutils
5 to use these functions in platform agnostic fashion.
6
7 $Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
8
9 """
10
11
12 #*****************************************************************************
13 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
14 #
15 # Distributed under the terms of the BSD License. The full license is in
16 # the file COPYING, distributed as part of this software.
17 #*****************************************************************************
18
19 from IPython import Release
20 __author__ = '%s <%s>' % Release.authors['Ville']
21 __license__ = Release.license
22
23
24 def set_term_title(title):
25 """ TBD """
@@ -1,2741 +1,2745 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Magic functions for InteractiveShell.
3 3
4 $Id: Magic.py 1005 2006-01-12 08:39:26Z fperez $"""
4 $Id: Magic.py 1014 2006-01-13 19:16:41Z vivainio $"""
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 from cStringIO import StringIO
35 35 from getopt import getopt
36 36 from pprint import pprint, pformat
37 37
38 38 # profile isn't bundled by default in Debian for license reasons
39 39 try:
40 40 import profile,pstats
41 41 except ImportError:
42 42 profile = pstats = None
43 43
44 44 # Homebrewed
45 45 from IPython import Debugger, OInspect, wildcard
46 46 from IPython.FakeModule import FakeModule
47 47 from IPython.Itpl import Itpl, itpl, printpl,itplns
48 48 from IPython.PyColorize import Parser
49 49 from IPython.ipstruct import Struct
50 50 from IPython.macro import Macro
51 51 from IPython.genutils import *
52
52 from IPython import platutils
53 53 #***************************************************************************
54 54 # Utility functions
55 55 def on_off(tag):
56 56 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
57 57 return ['OFF','ON'][tag]
58 58
59 59 class Bunch: pass
60 60
61 61 #***************************************************************************
62 62 # Main class implementing Magic functionality
63 63 class Magic:
64 64 """Magic functions for InteractiveShell.
65 65
66 66 Shell functions which can be reached as %function_name. All magic
67 67 functions should accept a string, which they can parse for their own
68 68 needs. This can make some functions easier to type, eg `%cd ../`
69 69 vs. `%cd("../")`
70 70
71 71 ALL definitions MUST begin with the prefix magic_. The user won't need it
72 72 at the command line, but it is is needed in the definition. """
73 73
74 74 # class globals
75 75 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
76 76 'Automagic is ON, % prefix NOT needed for magic functions.']
77 77
78 78 #......................................................................
79 79 # some utility functions
80 80
81 81 def __init__(self,shell):
82 82
83 83 self.options_table = {}
84 84 if profile is None:
85 85 self.magic_prun = self.profile_missing_notice
86 86 self.shell = shell
87 87
88 88 # namespace for holding state we may need
89 89 self._magic_state = Bunch()
90 90
91 91 def profile_missing_notice(self, *args, **kwargs):
92 92 error("""\
93 93 The profile module could not be found. If you are a Debian user,
94 94 it has been removed from the standard Debian package because of its non-free
95 95 license. To use profiling, please install"python2.3-profiler" from non-free.""")
96 96
97 97 def default_option(self,fn,optstr):
98 98 """Make an entry in the options_table for fn, with value optstr"""
99 99
100 100 if fn not in self.lsmagic():
101 101 error("%s is not a magic function" % fn)
102 102 self.options_table[fn] = optstr
103 103
104 104 def lsmagic(self):
105 105 """Return a list of currently available magic functions.
106 106
107 107 Gives a list of the bare names after mangling (['ls','cd', ...], not
108 108 ['magic_ls','magic_cd',...]"""
109 109
110 110 # FIXME. This needs a cleanup, in the way the magics list is built.
111 111
112 112 # magics in class definition
113 113 class_magic = lambda fn: fn.startswith('magic_') and \
114 114 callable(Magic.__dict__[fn])
115 115 # in instance namespace (run-time user additions)
116 116 inst_magic = lambda fn: fn.startswith('magic_') and \
117 117 callable(self.__dict__[fn])
118 118 # and bound magics by user (so they can access self):
119 119 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
120 120 callable(self.__class__.__dict__[fn])
121 121 magics = filter(class_magic,Magic.__dict__.keys()) + \
122 122 filter(inst_magic,self.__dict__.keys()) + \
123 123 filter(inst_bound_magic,self.__class__.__dict__.keys())
124 124 out = []
125 125 for fn in magics:
126 126 out.append(fn.replace('magic_','',1))
127 127 out.sort()
128 128 return out
129 129
130 130 def extract_input_slices(self,slices):
131 131 """Return as a string a set of input history slices.
132 132
133 133 The set of slices is given as a list of strings (like ['1','4:8','9'],
134 134 since this function is for use by magic functions which get their
135 135 arguments as strings.
136 136
137 137 Note that slices can be called with two notations:
138 138
139 139 N:M -> standard python form, means including items N...(M-1).
140 140
141 141 N-M -> include items N..M (closed endpoint)."""
142 142
143 143 cmds = []
144 144 for chunk in slices:
145 145 if ':' in chunk:
146 146 ini,fin = map(int,chunk.split(':'))
147 147 elif '-' in chunk:
148 148 ini,fin = map(int,chunk.split('-'))
149 149 fin += 1
150 150 else:
151 151 ini = int(chunk)
152 152 fin = ini+1
153 153 cmds.append(self.shell.input_hist[ini:fin])
154 154 return cmds
155 155
156 156 def _ofind(self,oname):
157 157 """Find an object in the available namespaces.
158 158
159 159 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
160 160
161 161 Has special code to detect magic functions.
162 162 """
163 163
164 164 oname = oname.strip()
165 165
166 166 # Namespaces to search in:
167 167 user_ns = self.shell.user_ns
168 168 internal_ns = self.shell.internal_ns
169 169 builtin_ns = __builtin__.__dict__
170 170 alias_ns = self.shell.alias_table
171 171
172 172 # Put them in a list. The order is important so that we find things in
173 173 # the same order that Python finds them.
174 174 namespaces = [ ('Interactive',user_ns),
175 175 ('IPython internal',internal_ns),
176 176 ('Python builtin',builtin_ns),
177 177 ('Alias',alias_ns),
178 178 ]
179 179
180 180 # initialize results to 'null'
181 181 found = 0; obj = None; ospace = None; ds = None;
182 182 ismagic = 0; isalias = 0
183 183
184 184 # Look for the given name by splitting it in parts. If the head is
185 185 # found, then we look for all the remaining parts as members, and only
186 186 # declare success if we can find them all.
187 187 oname_parts = oname.split('.')
188 188 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
189 189 for nsname,ns in namespaces:
190 190 try:
191 191 obj = ns[oname_head]
192 192 except KeyError:
193 193 continue
194 194 else:
195 195 for part in oname_rest:
196 196 try:
197 197 obj = getattr(obj,part)
198 198 except:
199 199 # Blanket except b/c some badly implemented objects
200 200 # allow __getattr__ to raise exceptions other than
201 201 # AttributeError, which then crashes IPython.
202 202 break
203 203 else:
204 204 # If we finish the for loop (no break), we got all members
205 205 found = 1
206 206 ospace = nsname
207 207 if ns == alias_ns:
208 208 isalias = 1
209 209 break # namespace loop
210 210
211 211 # Try to see if it's magic
212 212 if not found:
213 213 if oname.startswith(self.shell.ESC_MAGIC):
214 214 oname = oname[1:]
215 215 obj = getattr(self,'magic_'+oname,None)
216 216 if obj is not None:
217 217 found = 1
218 218 ospace = 'IPython internal'
219 219 ismagic = 1
220 220
221 221 # Last try: special-case some literals like '', [], {}, etc:
222 222 if not found and oname_head in ["''",'""','[]','{}','()']:
223 223 obj = eval(oname_head)
224 224 found = 1
225 225 ospace = 'Interactive'
226 226
227 227 return {'found':found, 'obj':obj, 'namespace':ospace,
228 228 'ismagic':ismagic, 'isalias':isalias}
229 229
230 230 def arg_err(self,func):
231 231 """Print docstring if incorrect arguments were passed"""
232 232 print 'Error in arguments:'
233 233 print OInspect.getdoc(func)
234 234
235 235 def format_latex(self,strng):
236 236 """Format a string for latex inclusion."""
237 237
238 238 # Characters that need to be escaped for latex:
239 239 escape_re = re.compile(r'(%|_|\$|#)',re.MULTILINE)
240 240 # Magic command names as headers:
241 241 cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
242 242 re.MULTILINE)
243 243 # Magic commands
244 244 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
245 245 re.MULTILINE)
246 246 # Paragraph continue
247 247 par_re = re.compile(r'\\$',re.MULTILINE)
248 248
249 249 # The "\n" symbol
250 250 newline_re = re.compile(r'\\n')
251 251
252 252 # Now build the string for output:
253 253 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
254 254 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
255 255 strng)
256 256 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
257 257 strng = par_re.sub(r'\\\\',strng)
258 258 strng = escape_re.sub(r'\\\1',strng)
259 259 strng = newline_re.sub(r'\\textbackslash{}n',strng)
260 260 return strng
261 261
262 262 def format_screen(self,strng):
263 263 """Format a string for screen printing.
264 264
265 265 This removes some latex-type format codes."""
266 266 # Paragraph continue
267 267 par_re = re.compile(r'\\$',re.MULTILINE)
268 268 strng = par_re.sub('',strng)
269 269 return strng
270 270
271 271 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
272 272 """Parse options passed to an argument string.
273 273
274 274 The interface is similar to that of getopt(), but it returns back a
275 275 Struct with the options as keys and the stripped argument string still
276 276 as a string.
277 277
278 278 arg_str is quoted as a true sys.argv vector by using shlex.split.
279 279 This allows us to easily expand variables, glob files, quote
280 280 arguments, etc.
281 281
282 282 Options:
283 283 -mode: default 'string'. If given as 'list', the argument string is
284 284 returned as a list (split on whitespace) instead of a string.
285 285
286 286 -list_all: put all option values in lists. Normally only options
287 287 appearing more than once are put in a list."""
288 288
289 289 # inject default options at the beginning of the input line
290 290 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
291 291 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
292 292
293 293 mode = kw.get('mode','string')
294 294 if mode not in ['string','list']:
295 295 raise ValueError,'incorrect mode given: %s' % mode
296 296 # Get options
297 297 list_all = kw.get('list_all',0)
298 298
299 299 # Check if we have more than one argument to warrant extra processing:
300 300 odict = {} # Dictionary with options
301 301 args = arg_str.split()
302 302 if len(args) >= 1:
303 303 # If the list of inputs only has 0 or 1 thing in it, there's no
304 304 # need to look for options
305 305 argv = shlex_split(arg_str)
306 306 # Do regular option processing
307 307 opts,args = getopt(argv,opt_str,*long_opts)
308 308 for o,a in opts:
309 309 if o.startswith('--'):
310 310 o = o[2:]
311 311 else:
312 312 o = o[1:]
313 313 try:
314 314 odict[o].append(a)
315 315 except AttributeError:
316 316 odict[o] = [odict[o],a]
317 317 except KeyError:
318 318 if list_all:
319 319 odict[o] = [a]
320 320 else:
321 321 odict[o] = a
322 322
323 323 # Prepare opts,args for return
324 324 opts = Struct(odict)
325 325 if mode == 'string':
326 326 args = ' '.join(args)
327 327
328 328 return opts,args
329 329
330 330 #......................................................................
331 331 # And now the actual magic functions
332 332
333 333 # Functions for IPython shell work (vars,funcs, config, etc)
334 334 def magic_lsmagic(self, parameter_s = ''):
335 335 """List currently available magic functions."""
336 336 mesc = self.shell.ESC_MAGIC
337 337 print 'Available magic functions:\n'+mesc+\
338 338 (' '+mesc).join(self.lsmagic())
339 339 print '\n' + Magic.auto_status[self.shell.rc.automagic]
340 340 return None
341 341
342 342 def magic_magic(self, parameter_s = ''):
343 343 """Print information about the magic function system."""
344 344
345 345 mode = ''
346 346 try:
347 347 if parameter_s.split()[0] == '-latex':
348 348 mode = 'latex'
349 349 except:
350 350 pass
351 351
352 352 magic_docs = []
353 353 for fname in self.lsmagic():
354 354 mname = 'magic_' + fname
355 355 for space in (Magic,self,self.__class__):
356 356 try:
357 357 fn = space.__dict__[mname]
358 358 except KeyError:
359 359 pass
360 360 else:
361 361 break
362 362 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
363 363 fname,fn.__doc__))
364 364 magic_docs = ''.join(magic_docs)
365 365
366 366 if mode == 'latex':
367 367 print self.format_latex(magic_docs)
368 368 return
369 369 else:
370 370 magic_docs = self.format_screen(magic_docs)
371 371
372 372 outmsg = """
373 373 IPython's 'magic' functions
374 374 ===========================
375 375
376 376 The magic function system provides a series of functions which allow you to
377 377 control the behavior of IPython itself, plus a lot of system-type
378 378 features. All these functions are prefixed with a % character, but parameters
379 379 are given without parentheses or quotes.
380 380
381 381 NOTE: If you have 'automagic' enabled (via the command line option or with the
382 382 %automagic function), you don't need to type in the % explicitly. By default,
383 383 IPython ships with automagic on, so you should only rarely need the % escape.
384 384
385 385 Example: typing '%cd mydir' (without the quotes) changes you working directory
386 386 to 'mydir', if it exists.
387 387
388 388 You can define your own magic functions to extend the system. See the supplied
389 389 ipythonrc and example-magic.py files for details (in your ipython
390 390 configuration directory, typically $HOME/.ipython/).
391 391
392 392 You can also define your own aliased names for magic functions. In your
393 393 ipythonrc file, placing a line like:
394 394
395 395 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
396 396
397 397 will define %pf as a new name for %profile.
398 398
399 399 You can also call magics in code using the ipmagic() function, which IPython
400 400 automatically adds to the builtin namespace. Type 'ipmagic?' for details.
401 401
402 402 For a list of the available magic functions, use %lsmagic. For a description
403 403 of any of them, type %magic_name?, e.g. '%cd?'.
404 404
405 405 Currently the magic system has the following functions:\n"""
406 406
407 407 mesc = self.shell.ESC_MAGIC
408 408 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
409 409 "\n\n%s%s\n\n%s" % (outmsg,
410 410 magic_docs,mesc,mesc,
411 411 (' '+mesc).join(self.lsmagic()),
412 412 Magic.auto_status[self.shell.rc.automagic] ) )
413 413
414 414 page(outmsg,screen_lines=self.shell.rc.screen_length)
415 415
416 416 def magic_automagic(self, parameter_s = ''):
417 417 """Make magic functions callable without having to type the initial %.
418 418
419 419 Toggles on/off (when off, you must call it as %automagic, of
420 420 course). Note that magic functions have lowest priority, so if there's
421 421 a variable whose name collides with that of a magic fn, automagic
422 422 won't work for that function (you get the variable instead). However,
423 423 if you delete the variable (del var), the previously shadowed magic
424 424 function becomes visible to automagic again."""
425 425
426 426 rc = self.shell.rc
427 427 rc.automagic = not rc.automagic
428 428 print '\n' + Magic.auto_status[rc.automagic]
429 429
430 430 def magic_autocall(self, parameter_s = ''):
431 431 """Make functions callable without having to type parentheses.
432 432
433 433 Usage:
434 434
435 435 %autocall [mode]
436 436
437 437 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
438 438 value is toggled on and off (remembering the previous state)."""
439 439
440 440 rc = self.shell.rc
441 441
442 442 if parameter_s:
443 443 arg = int(parameter_s)
444 444 else:
445 445 arg = 'toggle'
446 446
447 447 if not arg in (0,1,2,'toggle'):
448 448 error('Valid modes: (0->Off, 1->Smart, 2->Full')
449 449 return
450 450
451 451 if arg in (0,1,2):
452 452 rc.autocall = arg
453 453 else: # toggle
454 454 if rc.autocall:
455 455 self._magic_state.autocall_save = rc.autocall
456 456 rc.autocall = 0
457 457 else:
458 458 try:
459 459 rc.autocall = self._magic_state.autocall_save
460 460 except AttributeError:
461 461 rc.autocall = self._magic_state.autocall_save = 1
462 462
463 463 print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
464 464
465 465 def magic_autoindent(self, parameter_s = ''):
466 466 """Toggle autoindent on/off (if available)."""
467 467
468 468 self.shell.set_autoindent()
469 469 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
470 470
471 471 def magic_system_verbose(self, parameter_s = ''):
472 472 """Toggle verbose printing of system calls on/off."""
473 473
474 474 self.shell.rc_set_toggle('system_verbose')
475 475 print "System verbose printing is:",\
476 476 ['OFF','ON'][self.shell.rc.system_verbose]
477 477
478 478 def magic_history(self, parameter_s = ''):
479 479 """Print input history (_i<n> variables), with most recent last.
480 480
481 481 %history [-n] -> print at most 40 inputs (some may be multi-line)\\
482 482 %history [-n] n -> print at most n inputs\\
483 483 %history [-n] n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
484 484
485 485 Each input's number <n> is shown, and is accessible as the
486 486 automatically generated variable _i<n>. Multi-line statements are
487 487 printed starting at a new line for easy copy/paste.
488 488
489 489 If option -n is used, input numbers are not printed. This is useful if
490 490 you want to get a printout of many lines which can be directly pasted
491 491 into a text editor.
492 492
493 493 This feature is only available if numbered prompts are in use."""
494 494
495 495 shell = self.shell
496 496 if not shell.outputcache.do_full_cache:
497 497 print 'This feature is only available if numbered prompts are in use.'
498 498 return
499 499 opts,args = self.parse_options(parameter_s,'n',mode='list')
500 500
501 501 input_hist = shell.input_hist
502 502 default_length = 40
503 503 if len(args) == 0:
504 504 final = len(input_hist)
505 505 init = max(1,final-default_length)
506 506 elif len(args) == 1:
507 507 final = len(input_hist)
508 508 init = max(1,final-int(args[0]))
509 509 elif len(args) == 2:
510 510 init,final = map(int,args)
511 511 else:
512 512 warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
513 513 print self.magic_hist.__doc__
514 514 return
515 515 width = len(str(final))
516 516 line_sep = ['','\n']
517 517 print_nums = not opts.has_key('n')
518 518 for in_num in range(init,final):
519 519 inline = input_hist[in_num]
520 520 multiline = int(inline.count('\n') > 1)
521 521 if print_nums:
522 522 print '%s:%s' % (str(in_num).ljust(width),line_sep[multiline]),
523 523 print inline,
524 524
525 525 def magic_hist(self, parameter_s=''):
526 526 """Alternate name for %history."""
527 527 return self.magic_history(parameter_s)
528 528
529 529 def magic_p(self, parameter_s=''):
530 530 """Just a short alias for Python's 'print'."""
531 531 exec 'print ' + parameter_s in self.shell.user_ns
532 532
533 533 def magic_r(self, parameter_s=''):
534 534 """Repeat previous input.
535 535
536 536 If given an argument, repeats the previous command which starts with
537 537 the same string, otherwise it just repeats the previous input.
538 538
539 539 Shell escaped commands (with ! as first character) are not recognized
540 540 by this system, only pure python code and magic commands.
541 541 """
542 542
543 543 start = parameter_s.strip()
544 544 esc_magic = self.shell.ESC_MAGIC
545 545 # Identify magic commands even if automagic is on (which means
546 546 # the in-memory version is different from that typed by the user).
547 547 if self.shell.rc.automagic:
548 548 start_magic = esc_magic+start
549 549 else:
550 550 start_magic = start
551 551 # Look through the input history in reverse
552 552 for n in range(len(self.shell.input_hist)-2,0,-1):
553 553 input = self.shell.input_hist[n]
554 554 # skip plain 'r' lines so we don't recurse to infinity
555 555 if input != 'ipmagic("r")\n' and \
556 556 (input.startswith(start) or input.startswith(start_magic)):
557 557 #print 'match',`input` # dbg
558 558 print 'Executing:',input,
559 559 self.shell.runlines(input)
560 560 return
561 561 print 'No previous input matching `%s` found.' % start
562 562
563 563 def magic_page(self, parameter_s=''):
564 564 """Pretty print the object and display it through a pager.
565 565
566 566 If no parameter is given, use _ (last output)."""
567 567 # After a function contributed by Olivier Aubert, slightly modified.
568 568
569 569 oname = parameter_s and parameter_s or '_'
570 570 info = self._ofind(oname)
571 571 if info['found']:
572 572 page(pformat(info['obj']))
573 573 else:
574 574 print 'Object `%s` not found' % oname
575 575
576 576 def magic_profile(self, parameter_s=''):
577 577 """Print your currently active IPyhton profile."""
578 578 if self.shell.rc.profile:
579 579 printpl('Current IPython profile: $self.shell.rc.profile.')
580 580 else:
581 581 print 'No profile active.'
582 582
583 583 def _inspect(self,meth,oname,**kw):
584 584 """Generic interface to the inspector system.
585 585
586 586 This function is meant to be called by pdef, pdoc & friends."""
587 587
588 588 oname = oname.strip()
589 589 info = Struct(self._ofind(oname))
590 590 if info.found:
591 591 pmethod = getattr(self.shell.inspector,meth)
592 592 formatter = info.ismagic and self.format_screen or None
593 593 if meth == 'pdoc':
594 594 pmethod(info.obj,oname,formatter)
595 595 elif meth == 'pinfo':
596 596 pmethod(info.obj,oname,formatter,info,**kw)
597 597 else:
598 598 pmethod(info.obj,oname)
599 599 else:
600 600 print 'Object `%s` not found.' % oname
601 601 return 'not found' # so callers can take other action
602 602
603 603 def magic_pdef(self, parameter_s=''):
604 604 """Print the definition header for any callable object.
605 605
606 606 If the object is a class, print the constructor information."""
607 607 self._inspect('pdef',parameter_s)
608 608
609 609 def magic_pdoc(self, parameter_s=''):
610 610 """Print the docstring for an object.
611 611
612 612 If the given object is a class, it will print both the class and the
613 613 constructor docstrings."""
614 614 self._inspect('pdoc',parameter_s)
615 615
616 616 def magic_psource(self, parameter_s=''):
617 617 """Print (or run through pager) the source code for an object."""
618 618 self._inspect('psource',parameter_s)
619 619
620 620 def magic_pfile(self, parameter_s=''):
621 621 """Print (or run through pager) the file where an object is defined.
622 622
623 623 The file opens at the line where the object definition begins. IPython
624 624 will honor the environment variable PAGER if set, and otherwise will
625 625 do its best to print the file in a convenient form.
626 626
627 627 If the given argument is not an object currently defined, IPython will
628 628 try to interpret it as a filename (automatically adding a .py extension
629 629 if needed). You can thus use %pfile as a syntax highlighting code
630 630 viewer."""
631 631
632 632 # first interpret argument as an object name
633 633 out = self._inspect('pfile',parameter_s)
634 634 # if not, try the input as a filename
635 635 if out == 'not found':
636 636 try:
637 637 filename = get_py_filename(parameter_s)
638 638 except IOError,msg:
639 639 print msg
640 640 return
641 641 page(self.shell.inspector.format(file(filename).read()))
642 642
643 643 def magic_pinfo(self, parameter_s=''):
644 644 """Provide detailed information about an object.
645 645
646 646 '%pinfo object' is just a synonym for object? or ?object."""
647 647
648 648 #print 'pinfo par: <%s>' % parameter_s # dbg
649 649
650 650 # detail_level: 0 -> obj? , 1 -> obj??
651 651 detail_level = 0
652 652 # We need to detect if we got called as 'pinfo pinfo foo', which can
653 653 # happen if the user types 'pinfo foo?' at the cmd line.
654 654 pinfo,qmark1,oname,qmark2 = \
655 655 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
656 656 if pinfo or qmark1 or qmark2:
657 657 detail_level = 1
658 658 if "*" in oname:
659 659 self.magic_psearch(oname)
660 660 else:
661 661 self._inspect('pinfo',oname,detail_level=detail_level)
662 662
663 663 def magic_psearch(self, parameter_s=''):
664 664 """Search for object in namespaces by wildcard.
665 665
666 666 %psearch [options] PATTERN [OBJECT TYPE]
667 667
668 668 Note: ? can be used as a synonym for %psearch, at the beginning or at
669 669 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
670 670 rest of the command line must be unchanged (options come first), so
671 671 for example the following forms are equivalent
672 672
673 673 %psearch -i a* function
674 674 -i a* function?
675 675 ?-i a* function
676 676
677 677 Arguments:
678 678
679 679 PATTERN
680 680
681 681 where PATTERN is a string containing * as a wildcard similar to its
682 682 use in a shell. The pattern is matched in all namespaces on the
683 683 search path. By default objects starting with a single _ are not
684 684 matched, many IPython generated objects have a single
685 685 underscore. The default is case insensitive matching. Matching is
686 686 also done on the attributes of objects and not only on the objects
687 687 in a module.
688 688
689 689 [OBJECT TYPE]
690 690
691 691 Is the name of a python type from the types module. The name is
692 692 given in lowercase without the ending type, ex. StringType is
693 693 written string. By adding a type here only objects matching the
694 694 given type are matched. Using all here makes the pattern match all
695 695 types (this is the default).
696 696
697 697 Options:
698 698
699 699 -a: makes the pattern match even objects whose names start with a
700 700 single underscore. These names are normally ommitted from the
701 701 search.
702 702
703 703 -i/-c: make the pattern case insensitive/sensitive. If neither of
704 704 these options is given, the default is read from your ipythonrc
705 705 file. The option name which sets this value is
706 706 'wildcards_case_sensitive'. If this option is not specified in your
707 707 ipythonrc file, IPython's internal default is to do a case sensitive
708 708 search.
709 709
710 710 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
711 711 specifiy can be searched in any of the following namespaces:
712 712 'builtin', 'user', 'user_global','internal', 'alias', where
713 713 'builtin' and 'user' are the search defaults. Note that you should
714 714 not use quotes when specifying namespaces.
715 715
716 716 'Builtin' contains the python module builtin, 'user' contains all
717 717 user data, 'alias' only contain the shell aliases and no python
718 718 objects, 'internal' contains objects used by IPython. The
719 719 'user_global' namespace is only used by embedded IPython instances,
720 720 and it contains module-level globals. You can add namespaces to the
721 721 search with -s or exclude them with -e (these options can be given
722 722 more than once).
723 723
724 724 Examples:
725 725
726 726 %psearch a* -> objects beginning with an a
727 727 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
728 728 %psearch a* function -> all functions beginning with an a
729 729 %psearch re.e* -> objects beginning with an e in module re
730 730 %psearch r*.e* -> objects that start with e in modules starting in r
731 731 %psearch r*.* string -> all strings in modules beginning with r
732 732
733 733 Case sensitve search:
734 734
735 735 %psearch -c a* list all object beginning with lower case a
736 736
737 737 Show objects beginning with a single _:
738 738
739 739 %psearch -a _* list objects beginning with a single underscore"""
740 740
741 741 # default namespaces to be searched
742 742 def_search = ['user','builtin']
743 743
744 744 # Process options/args
745 745 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
746 746 opt = opts.get
747 747 shell = self.shell
748 748 psearch = shell.inspector.psearch
749 749
750 750 # select case options
751 751 if opts.has_key('i'):
752 752 ignore_case = True
753 753 elif opts.has_key('c'):
754 754 ignore_case = False
755 755 else:
756 756 ignore_case = not shell.rc.wildcards_case_sensitive
757 757
758 758 # Build list of namespaces to search from user options
759 759 def_search.extend(opt('s',[]))
760 760 ns_exclude = ns_exclude=opt('e',[])
761 761 ns_search = [nm for nm in def_search if nm not in ns_exclude]
762 762
763 763 # Call the actual search
764 764 try:
765 765 psearch(args,shell.ns_table,ns_search,
766 766 show_all=opt('a'),ignore_case=ignore_case)
767 767 except:
768 768 shell.showtraceback()
769 769
770 770 def magic_who_ls(self, parameter_s=''):
771 771 """Return a sorted list of all interactive variables.
772 772
773 773 If arguments are given, only variables of types matching these
774 774 arguments are returned."""
775 775
776 776 user_ns = self.shell.user_ns
777 777 internal_ns = self.shell.internal_ns
778 778 user_config_ns = self.shell.user_config_ns
779 779 out = []
780 780 typelist = parameter_s.split()
781 781
782 782 for i in user_ns:
783 783 if not (i.startswith('_') or i.startswith('_i')) \
784 784 and not (i in internal_ns or i in user_config_ns):
785 785 if typelist:
786 786 if type(user_ns[i]).__name__ in typelist:
787 787 out.append(i)
788 788 else:
789 789 out.append(i)
790 790 out.sort()
791 791 return out
792 792
793 793 def magic_who(self, parameter_s=''):
794 794 """Print all interactive variables, with some minimal formatting.
795 795
796 796 If any arguments are given, only variables whose type matches one of
797 797 these are printed. For example:
798 798
799 799 %who function str
800 800
801 801 will only list functions and strings, excluding all other types of
802 802 variables. To find the proper type names, simply use type(var) at a
803 803 command line to see how python prints type names. For example:
804 804
805 805 In [1]: type('hello')\\
806 806 Out[1]: <type 'str'>
807 807
808 808 indicates that the type name for strings is 'str'.
809 809
810 810 %who always excludes executed names loaded through your configuration
811 811 file and things which are internal to IPython.
812 812
813 813 This is deliberate, as typically you may load many modules and the
814 814 purpose of %who is to show you only what you've manually defined."""
815 815
816 816 varlist = self.magic_who_ls(parameter_s)
817 817 if not varlist:
818 818 print 'Interactive namespace is empty.'
819 819 return
820 820
821 821 # if we have variables, move on...
822 822
823 823 # stupid flushing problem: when prompts have no separators, stdout is
824 824 # getting lost. I'm starting to think this is a python bug. I'm having
825 825 # to force a flush with a print because even a sys.stdout.flush
826 826 # doesn't seem to do anything!
827 827
828 828 count = 0
829 829 for i in varlist:
830 830 print i+'\t',
831 831 count += 1
832 832 if count > 8:
833 833 count = 0
834 834 print
835 835 sys.stdout.flush() # FIXME. Why the hell isn't this flushing???
836 836
837 837 print # well, this does force a flush at the expense of an extra \n
838 838
839 839 def magic_whos(self, parameter_s=''):
840 840 """Like %who, but gives some extra information about each variable.
841 841
842 842 The same type filtering of %who can be applied here.
843 843
844 844 For all variables, the type is printed. Additionally it prints:
845 845
846 846 - For {},[],(): their length.
847 847
848 848 - For Numeric arrays, a summary with shape, number of elements,
849 849 typecode and size in memory.
850 850
851 851 - Everything else: a string representation, snipping their middle if
852 852 too long."""
853 853
854 854 varnames = self.magic_who_ls(parameter_s)
855 855 if not varnames:
856 856 print 'Interactive namespace is empty.'
857 857 return
858 858
859 859 # if we have variables, move on...
860 860
861 861 # for these types, show len() instead of data:
862 862 seq_types = [types.DictType,types.ListType,types.TupleType]
863 863
864 864 # for Numeric arrays, display summary info
865 865 try:
866 866 import Numeric
867 867 except ImportError:
868 868 array_type = None
869 869 else:
870 870 array_type = Numeric.ArrayType.__name__
871 871
872 872 # Find all variable names and types so we can figure out column sizes
873 873 get_vars = lambda i: self.shell.user_ns[i]
874 874 type_name = lambda v: type(v).__name__
875 875 varlist = map(get_vars,varnames)
876 876
877 877 typelist = []
878 878 for vv in varlist:
879 879 tt = type_name(vv)
880 880 if tt=='instance':
881 881 typelist.append(str(vv.__class__))
882 882 else:
883 883 typelist.append(tt)
884 884
885 885 # column labels and # of spaces as separator
886 886 varlabel = 'Variable'
887 887 typelabel = 'Type'
888 888 datalabel = 'Data/Info'
889 889 colsep = 3
890 890 # variable format strings
891 891 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
892 892 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
893 893 aformat = "%s: %s elems, type `%s`, %s bytes"
894 894 # find the size of the columns to format the output nicely
895 895 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
896 896 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
897 897 # table header
898 898 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
899 899 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
900 900 # and the table itself
901 901 kb = 1024
902 902 Mb = 1048576 # kb**2
903 903 for vname,var,vtype in zip(varnames,varlist,typelist):
904 904 print itpl(vformat),
905 905 if vtype in seq_types:
906 906 print len(var)
907 907 elif vtype==array_type:
908 908 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
909 909 vsize = Numeric.size(var)
910 910 vbytes = vsize*var.itemsize()
911 911 if vbytes < 100000:
912 912 print aformat % (vshape,vsize,var.typecode(),vbytes)
913 913 else:
914 914 print aformat % (vshape,vsize,var.typecode(),vbytes),
915 915 if vbytes < Mb:
916 916 print '(%s kb)' % (vbytes/kb,)
917 917 else:
918 918 print '(%s Mb)' % (vbytes/Mb,)
919 919 else:
920 920 vstr = str(var).replace('\n','\\n')
921 921 if len(vstr) < 50:
922 922 print vstr
923 923 else:
924 924 printpl(vfmt_short)
925 925
926 926 def magic_reset(self, parameter_s=''):
927 927 """Resets the namespace by removing all names defined by the user.
928 928
929 929 Input/Output history are left around in case you need them."""
930 930
931 931 ans = raw_input(
932 932 "Once deleted, variables cannot be recovered. Proceed (y/n)? ")
933 933 if not ans.lower() == 'y':
934 934 print 'Nothing done.'
935 935 return
936 936 user_ns = self.shell.user_ns
937 937 for i in self.magic_who_ls():
938 938 del(user_ns[i])
939 939
940 940 def magic_config(self,parameter_s=''):
941 941 """Show IPython's internal configuration."""
942 942
943 943 page('Current configuration structure:\n'+
944 944 pformat(self.shell.rc.dict()))
945 945
946 946 def magic_logstart(self,parameter_s=''):
947 947 """Start logging anywhere in a session.
948 948
949 949 %logstart [-o|-t] [log_name [log_mode]]
950 950
951 951 If no name is given, it defaults to a file named 'ipython_log.py' in your
952 952 current directory, in 'rotate' mode (see below).
953 953
954 954 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
955 955 history up to that point and then continues logging.
956 956
957 957 %logstart takes a second optional parameter: logging mode. This can be one
958 958 of (note that the modes are given unquoted):\\
959 959 append: well, that says it.\\
960 960 backup: rename (if exists) to name~ and start name.\\
961 961 global: single logfile in your home dir, appended to.\\
962 962 over : overwrite existing log.\\
963 963 rotate: create rotating logs name.1~, name.2~, etc.
964 964
965 965 Options:
966 966
967 967 -o: log also IPython's output. In this mode, all commands which
968 968 generate an Out[NN] prompt are recorded to the logfile, right after
969 969 their corresponding input line. The output lines are always
970 970 prepended with a '#[Out]# ' marker, so that the log remains valid
971 971 Python code.
972 972
973 973 Since this marker is always the same, filtering only the output from
974 974 a log is very easy, using for example a simple awk call:
975 975
976 976 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
977 977
978 978 -t: put timestamps before each input line logged (these are put in
979 979 comments)."""
980 980
981 981 opts,par = self.parse_options(parameter_s,'ot')
982 982 log_output = 'o' in opts
983 983 timestamp = 't' in opts
984 984
985 985 rc = self.shell.rc
986 986 logger = self.shell.logger
987 987
988 988 # if no args are given, the defaults set in the logger constructor by
989 989 # ipytohn remain valid
990 990 if par:
991 991 try:
992 992 logfname,logmode = par.split()
993 993 except:
994 994 logfname = par
995 995 logmode = 'backup'
996 996 else:
997 997 logfname = logger.logfname
998 998 logmode = logger.logmode
999 999 # put logfname into rc struct as if it had been called on the command
1000 1000 # line, so it ends up saved in the log header Save it in case we need
1001 1001 # to restore it...
1002 1002 old_logfile = rc.opts.get('logfile','')
1003 1003 if logfname:
1004 1004 logfname = os.path.expanduser(logfname)
1005 1005 rc.opts.logfile = logfname
1006 1006 loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
1007 1007 try:
1008 1008 started = logger.logstart(logfname,loghead,logmode,
1009 1009 log_output,timestamp)
1010 1010 except:
1011 1011 rc.opts.logfile = old_logfile
1012 1012 warn("Couldn't start log: %s" % sys.exc_info()[1])
1013 1013 else:
1014 1014 # log input history up to this point, optionally interleaving
1015 1015 # output if requested
1016 1016
1017 1017 if timestamp:
1018 1018 # disable timestamping for the previous history, since we've
1019 1019 # lost those already (no time machine here).
1020 1020 logger.timestamp = False
1021 1021 if log_output:
1022 1022 log_write = logger.log_write
1023 1023 input_hist = self.shell.input_hist
1024 1024 output_hist = self.shell.output_hist
1025 1025 for n in range(1,len(input_hist)-1):
1026 1026 log_write(input_hist[n].rstrip())
1027 1027 if n in output_hist:
1028 1028 log_write(repr(output_hist[n]),'output')
1029 1029 else:
1030 1030 logger.log_write(self.shell.input_hist[1:])
1031 1031 if timestamp:
1032 1032 # re-enable timestamping
1033 1033 logger.timestamp = True
1034 1034
1035 1035 print ('Activating auto-logging. '
1036 1036 'Current session state plus future input saved.')
1037 1037 logger.logstate()
1038 1038
1039 1039 def magic_logoff(self,parameter_s=''):
1040 1040 """Temporarily stop logging.
1041 1041
1042 1042 You must have previously started logging."""
1043 1043 self.shell.logger.switch_log(0)
1044 1044
1045 1045 def magic_logon(self,parameter_s=''):
1046 1046 """Restart logging.
1047 1047
1048 1048 This function is for restarting logging which you've temporarily
1049 1049 stopped with %logoff. For starting logging for the first time, you
1050 1050 must use the %logstart function, which allows you to specify an
1051 1051 optional log filename."""
1052 1052
1053 1053 self.shell.logger.switch_log(1)
1054 1054
1055 1055 def magic_logstate(self,parameter_s=''):
1056 1056 """Print the status of the logging system."""
1057 1057
1058 1058 self.shell.logger.logstate()
1059 1059
1060 1060 def magic_pdb(self, parameter_s=''):
1061 1061 """Control the calling of the pdb interactive debugger.
1062 1062
1063 1063 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1064 1064 argument it works as a toggle.
1065 1065
1066 1066 When an exception is triggered, IPython can optionally call the
1067 1067 interactive pdb debugger after the traceback printout. %pdb toggles
1068 1068 this feature on and off."""
1069 1069
1070 1070 par = parameter_s.strip().lower()
1071 1071
1072 1072 if par:
1073 1073 try:
1074 1074 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1075 1075 except KeyError:
1076 1076 print ('Incorrect argument. Use on/1, off/0, '
1077 1077 'or nothing for a toggle.')
1078 1078 return
1079 1079 else:
1080 1080 # toggle
1081 1081 new_pdb = not self.shell.InteractiveTB.call_pdb
1082 1082
1083 1083 # set on the shell
1084 1084 self.shell.call_pdb = new_pdb
1085 1085 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1086 1086
1087 1087 def magic_prun(self, parameter_s ='',user_mode=1,
1088 1088 opts=None,arg_lst=None,prog_ns=None):
1089 1089
1090 1090 """Run a statement through the python code profiler.
1091 1091
1092 1092 Usage:\\
1093 1093 %prun [options] statement
1094 1094
1095 1095 The given statement (which doesn't require quote marks) is run via the
1096 1096 python profiler in a manner similar to the profile.run() function.
1097 1097 Namespaces are internally managed to work correctly; profile.run
1098 1098 cannot be used in IPython because it makes certain assumptions about
1099 1099 namespaces which do not hold under IPython.
1100 1100
1101 1101 Options:
1102 1102
1103 1103 -l <limit>: you can place restrictions on what or how much of the
1104 1104 profile gets printed. The limit value can be:
1105 1105
1106 1106 * A string: only information for function names containing this string
1107 1107 is printed.
1108 1108
1109 1109 * An integer: only these many lines are printed.
1110 1110
1111 1111 * A float (between 0 and 1): this fraction of the report is printed
1112 1112 (for example, use a limit of 0.4 to see the topmost 40% only).
1113 1113
1114 1114 You can combine several limits with repeated use of the option. For
1115 1115 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1116 1116 information about class constructors.
1117 1117
1118 1118 -r: return the pstats.Stats object generated by the profiling. This
1119 1119 object has all the information about the profile in it, and you can
1120 1120 later use it for further analysis or in other functions.
1121 1121
1122 1122 Since magic functions have a particular form of calling which prevents
1123 1123 you from writing something like:\\
1124 1124 In [1]: p = %prun -r print 4 # invalid!\\
1125 1125 you must instead use IPython's automatic variables to assign this:\\
1126 1126 In [1]: %prun -r print 4 \\
1127 1127 Out[1]: <pstats.Stats instance at 0x8222cec>\\
1128 1128 In [2]: stats = _
1129 1129
1130 1130 If you really need to assign this value via an explicit function call,
1131 1131 you can always tap directly into the true name of the magic function
1132 1132 by using the ipmagic function (which IPython automatically adds to the
1133 1133 builtins):\\
1134 1134 In [3]: stats = ipmagic('prun','-r print 4')
1135 1135
1136 1136 You can type ipmagic? for more details on ipmagic.
1137 1137
1138 1138 -s <key>: sort profile by given key. You can provide more than one key
1139 1139 by using the option several times: '-s key1 -s key2 -s key3...'. The
1140 1140 default sorting key is 'time'.
1141 1141
1142 1142 The following is copied verbatim from the profile documentation
1143 1143 referenced below:
1144 1144
1145 1145 When more than one key is provided, additional keys are used as
1146 1146 secondary criteria when the there is equality in all keys selected
1147 1147 before them.
1148 1148
1149 1149 Abbreviations can be used for any key names, as long as the
1150 1150 abbreviation is unambiguous. The following are the keys currently
1151 1151 defined:
1152 1152
1153 1153 Valid Arg Meaning\\
1154 1154 "calls" call count\\
1155 1155 "cumulative" cumulative time\\
1156 1156 "file" file name\\
1157 1157 "module" file name\\
1158 1158 "pcalls" primitive call count\\
1159 1159 "line" line number\\
1160 1160 "name" function name\\
1161 1161 "nfl" name/file/line\\
1162 1162 "stdname" standard name\\
1163 1163 "time" internal time
1164 1164
1165 1165 Note that all sorts on statistics are in descending order (placing
1166 1166 most time consuming items first), where as name, file, and line number
1167 1167 searches are in ascending order (i.e., alphabetical). The subtle
1168 1168 distinction between "nfl" and "stdname" is that the standard name is a
1169 1169 sort of the name as printed, which means that the embedded line
1170 1170 numbers get compared in an odd way. For example, lines 3, 20, and 40
1171 1171 would (if the file names were the same) appear in the string order
1172 1172 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1173 1173 line numbers. In fact, sort_stats("nfl") is the same as
1174 1174 sort_stats("name", "file", "line").
1175 1175
1176 1176 -T <filename>: save profile results as shown on screen to a text
1177 1177 file. The profile is still shown on screen.
1178 1178
1179 1179 -D <filename>: save (via dump_stats) profile statistics to given
1180 1180 filename. This data is in a format understod by the pstats module, and
1181 1181 is generated by a call to the dump_stats() method of profile
1182 1182 objects. The profile is still shown on screen.
1183 1183
1184 1184 If you want to run complete programs under the profiler's control, use
1185 1185 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1186 1186 contains profiler specific options as described here.
1187 1187
1188 1188 You can read the complete documentation for the profile module with:\\
1189 1189 In [1]: import profile; profile.help() """
1190 1190
1191 1191 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1192 1192 # protect user quote marks
1193 1193 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1194 1194
1195 1195 if user_mode: # regular user call
1196 1196 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1197 1197 list_all=1)
1198 1198 namespace = self.shell.user_ns
1199 1199 else: # called to run a program by %run -p
1200 1200 try:
1201 1201 filename = get_py_filename(arg_lst[0])
1202 1202 except IOError,msg:
1203 1203 error(msg)
1204 1204 return
1205 1205
1206 1206 arg_str = 'execfile(filename,prog_ns)'
1207 1207 namespace = locals()
1208 1208
1209 1209 opts.merge(opts_def)
1210 1210
1211 1211 prof = profile.Profile()
1212 1212 try:
1213 1213 prof = prof.runctx(arg_str,namespace,namespace)
1214 1214 sys_exit = ''
1215 1215 except SystemExit:
1216 1216 sys_exit = """*** SystemExit exception caught in code being profiled."""
1217 1217
1218 1218 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1219 1219
1220 1220 lims = opts.l
1221 1221 if lims:
1222 1222 lims = [] # rebuild lims with ints/floats/strings
1223 1223 for lim in opts.l:
1224 1224 try:
1225 1225 lims.append(int(lim))
1226 1226 except ValueError:
1227 1227 try:
1228 1228 lims.append(float(lim))
1229 1229 except ValueError:
1230 1230 lims.append(lim)
1231 1231
1232 1232 # trap output
1233 1233 sys_stdout = sys.stdout
1234 1234 stdout_trap = StringIO()
1235 1235 try:
1236 1236 sys.stdout = stdout_trap
1237 1237 stats.print_stats(*lims)
1238 1238 finally:
1239 1239 sys.stdout = sys_stdout
1240 1240 output = stdout_trap.getvalue()
1241 1241 output = output.rstrip()
1242 1242
1243 1243 page(output,screen_lines=self.shell.rc.screen_length)
1244 1244 print sys_exit,
1245 1245
1246 1246 dump_file = opts.D[0]
1247 1247 text_file = opts.T[0]
1248 1248 if dump_file:
1249 1249 prof.dump_stats(dump_file)
1250 1250 print '\n*** Profile stats marshalled to file',\
1251 1251 `dump_file`+'.',sys_exit
1252 1252 if text_file:
1253 1253 file(text_file,'w').write(output)
1254 1254 print '\n*** Profile printout saved to text file',\
1255 1255 `text_file`+'.',sys_exit
1256 1256
1257 1257 if opts.has_key('r'):
1258 1258 return stats
1259 1259 else:
1260 1260 return None
1261 1261
1262 1262 def magic_run(self, parameter_s ='',runner=None):
1263 1263 """Run the named file inside IPython as a program.
1264 1264
1265 1265 Usage:\\
1266 1266 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1267 1267
1268 1268 Parameters after the filename are passed as command-line arguments to
1269 1269 the program (put in sys.argv). Then, control returns to IPython's
1270 1270 prompt.
1271 1271
1272 1272 This is similar to running at a system prompt:\\
1273 1273 $ python file args\\
1274 1274 but with the advantage of giving you IPython's tracebacks, and of
1275 1275 loading all variables into your interactive namespace for further use
1276 1276 (unless -p is used, see below).
1277 1277
1278 1278 The file is executed in a namespace initially consisting only of
1279 1279 __name__=='__main__' and sys.argv constructed as indicated. It thus
1280 1280 sees its environment as if it were being run as a stand-alone
1281 1281 program. But after execution, the IPython interactive namespace gets
1282 1282 updated with all variables defined in the program (except for __name__
1283 1283 and sys.argv). This allows for very convenient loading of code for
1284 1284 interactive work, while giving each program a 'clean sheet' to run in.
1285 1285
1286 1286 Options:
1287 1287
1288 1288 -n: __name__ is NOT set to '__main__', but to the running file's name
1289 1289 without extension (as python does under import). This allows running
1290 1290 scripts and reloading the definitions in them without calling code
1291 1291 protected by an ' if __name__ == "__main__" ' clause.
1292 1292
1293 1293 -i: run the file in IPython's namespace instead of an empty one. This
1294 1294 is useful if you are experimenting with code written in a text editor
1295 1295 which depends on variables defined interactively.
1296 1296
1297 1297 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1298 1298 being run. This is particularly useful if IPython is being used to
1299 1299 run unittests, which always exit with a sys.exit() call. In such
1300 1300 cases you are interested in the output of the test results, not in
1301 1301 seeing a traceback of the unittest module.
1302 1302
1303 1303 -t: print timing information at the end of the run. IPython will give
1304 1304 you an estimated CPU time consumption for your script, which under
1305 1305 Unix uses the resource module to avoid the wraparound problems of
1306 1306 time.clock(). Under Unix, an estimate of time spent on system tasks
1307 1307 is also given (for Windows platforms this is reported as 0.0).
1308 1308
1309 1309 If -t is given, an additional -N<N> option can be given, where <N>
1310 1310 must be an integer indicating how many times you want the script to
1311 1311 run. The final timing report will include total and per run results.
1312 1312
1313 1313 For example (testing the script uniq_stable.py):
1314 1314
1315 1315 In [1]: run -t uniq_stable
1316 1316
1317 1317 IPython CPU timings (estimated):\\
1318 1318 User : 0.19597 s.\\
1319 1319 System: 0.0 s.\\
1320 1320
1321 1321 In [2]: run -t -N5 uniq_stable
1322 1322
1323 1323 IPython CPU timings (estimated):\\
1324 1324 Total runs performed: 5\\
1325 1325 Times : Total Per run\\
1326 1326 User : 0.910862 s, 0.1821724 s.\\
1327 1327 System: 0.0 s, 0.0 s.
1328 1328
1329 1329 -d: run your program under the control of pdb, the Python debugger.
1330 1330 This allows you to execute your program step by step, watch variables,
1331 1331 etc. Internally, what IPython does is similar to calling:
1332 1332
1333 1333 pdb.run('execfile("YOURFILENAME")')
1334 1334
1335 1335 with a breakpoint set on line 1 of your file. You can change the line
1336 1336 number for this automatic breakpoint to be <N> by using the -bN option
1337 1337 (where N must be an integer). For example:
1338 1338
1339 1339 %run -d -b40 myscript
1340 1340
1341 1341 will set the first breakpoint at line 40 in myscript.py. Note that
1342 1342 the first breakpoint must be set on a line which actually does
1343 1343 something (not a comment or docstring) for it to stop execution.
1344 1344
1345 1345 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1346 1346 first enter 'c' (without qoutes) to start execution up to the first
1347 1347 breakpoint.
1348 1348
1349 1349 Entering 'help' gives information about the use of the debugger. You
1350 1350 can easily see pdb's full documentation with "import pdb;pdb.help()"
1351 1351 at a prompt.
1352 1352
1353 1353 -p: run program under the control of the Python profiler module (which
1354 1354 prints a detailed report of execution times, function calls, etc).
1355 1355
1356 1356 You can pass other options after -p which affect the behavior of the
1357 1357 profiler itself. See the docs for %prun for details.
1358 1358
1359 1359 In this mode, the program's variables do NOT propagate back to the
1360 1360 IPython interactive namespace (because they remain in the namespace
1361 1361 where the profiler executes them).
1362 1362
1363 1363 Internally this triggers a call to %prun, see its documentation for
1364 1364 details on the options available specifically for profiling."""
1365 1365
1366 1366 # get arguments and set sys.argv for program to be run.
1367 1367 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1368 1368 mode='list',list_all=1)
1369 1369
1370 1370 try:
1371 1371 filename = get_py_filename(arg_lst[0])
1372 1372 except IndexError:
1373 1373 warn('you must provide at least a filename.')
1374 1374 print '\n%run:\n',OInspect.getdoc(self.magic_run)
1375 1375 return
1376 1376 except IOError,msg:
1377 1377 error(msg)
1378 1378 return
1379 1379
1380 1380 # Control the response to exit() calls made by the script being run
1381 1381 exit_ignore = opts.has_key('e')
1382 1382
1383 1383 # Make sure that the running script gets a proper sys.argv as if it
1384 1384 # were run from a system shell.
1385 1385 save_argv = sys.argv # save it for later restoring
1386 1386 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1387 1387
1388 1388 if opts.has_key('i'):
1389 1389 prog_ns = self.shell.user_ns
1390 1390 __name__save = self.shell.user_ns['__name__']
1391 1391 prog_ns['__name__'] = '__main__'
1392 1392 else:
1393 1393 if opts.has_key('n'):
1394 1394 name = os.path.splitext(os.path.basename(filename))[0]
1395 1395 else:
1396 1396 name = '__main__'
1397 1397 prog_ns = {'__name__':name}
1398 1398
1399 1399 # pickle fix. See iplib for an explanation. But we need to make sure
1400 1400 # that, if we overwrite __main__, we replace it at the end
1401 1401 if prog_ns['__name__'] == '__main__':
1402 1402 restore_main = sys.modules['__main__']
1403 1403 else:
1404 1404 restore_main = False
1405 1405
1406 1406 sys.modules[prog_ns['__name__']] = FakeModule(prog_ns)
1407 1407
1408 1408 stats = None
1409 1409 try:
1410 1410 if opts.has_key('p'):
1411 1411 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1412 1412 else:
1413 1413 if opts.has_key('d'):
1414 1414 deb = Debugger.Pdb(self.shell.rc.colors)
1415 1415 # reset Breakpoint state, which is moronically kept
1416 1416 # in a class
1417 1417 bdb.Breakpoint.next = 1
1418 1418 bdb.Breakpoint.bplist = {}
1419 1419 bdb.Breakpoint.bpbynumber = [None]
1420 1420 # Set an initial breakpoint to stop execution
1421 1421 maxtries = 10
1422 1422 bp = int(opts.get('b',[1])[0])
1423 1423 checkline = deb.checkline(filename,bp)
1424 1424 if not checkline:
1425 1425 for bp in range(bp+1,bp+maxtries+1):
1426 1426 if deb.checkline(filename,bp):
1427 1427 break
1428 1428 else:
1429 1429 msg = ("\nI failed to find a valid line to set "
1430 1430 "a breakpoint\n"
1431 1431 "after trying up to line: %s.\n"
1432 1432 "Please set a valid breakpoint manually "
1433 1433 "with the -b option." % bp)
1434 1434 error(msg)
1435 1435 return
1436 1436 # if we find a good linenumber, set the breakpoint
1437 1437 deb.do_break('%s:%s' % (filename,bp))
1438 1438 # Start file run
1439 1439 print "NOTE: Enter 'c' at the",
1440 1440 print "ipdb> prompt to start your script."
1441 1441 try:
1442 1442 deb.run('execfile("%s")' % filename,prog_ns)
1443 1443 except:
1444 1444 etype, value, tb = sys.exc_info()
1445 1445 # Skip three frames in the traceback: the %run one,
1446 1446 # one inside bdb.py, and the command-line typed by the
1447 1447 # user (run by exec in pdb itself).
1448 1448 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1449 1449 else:
1450 1450 if runner is None:
1451 1451 runner = self.shell.safe_execfile
1452 1452 if opts.has_key('t'):
1453 1453 try:
1454 1454 nruns = int(opts['N'][0])
1455 1455 if nruns < 1:
1456 1456 error('Number of runs must be >=1')
1457 1457 return
1458 1458 except (KeyError):
1459 1459 nruns = 1
1460 1460 if nruns == 1:
1461 1461 t0 = clock2()
1462 1462 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1463 1463 t1 = clock2()
1464 1464 t_usr = t1[0]-t0[0]
1465 1465 t_sys = t1[1]-t1[1]
1466 1466 print "\nIPython CPU timings (estimated):"
1467 1467 print " User : %10s s." % t_usr
1468 1468 print " System: %10s s." % t_sys
1469 1469 else:
1470 1470 runs = range(nruns)
1471 1471 t0 = clock2()
1472 1472 for nr in runs:
1473 1473 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1474 1474 t1 = clock2()
1475 1475 t_usr = t1[0]-t0[0]
1476 1476 t_sys = t1[1]-t1[1]
1477 1477 print "\nIPython CPU timings (estimated):"
1478 1478 print "Total runs performed:",nruns
1479 1479 print " Times : %10s %10s" % ('Total','Per run')
1480 1480 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1481 1481 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1482 1482
1483 1483 else:
1484 1484 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1485 1485 if opts.has_key('i'):
1486 1486 self.shell.user_ns['__name__'] = __name__save
1487 1487 else:
1488 1488 # update IPython interactive namespace
1489 1489 del prog_ns['__name__']
1490 1490 self.shell.user_ns.update(prog_ns)
1491 1491 finally:
1492 1492 sys.argv = save_argv
1493 1493 if restore_main:
1494 1494 sys.modules['__main__'] = restore_main
1495 1495 return stats
1496 1496
1497 1497 def magic_runlog(self, parameter_s =''):
1498 1498 """Run files as logs.
1499 1499
1500 1500 Usage:\\
1501 1501 %runlog file1 file2 ...
1502 1502
1503 1503 Run the named files (treating them as log files) in sequence inside
1504 1504 the interpreter, and return to the prompt. This is much slower than
1505 1505 %run because each line is executed in a try/except block, but it
1506 1506 allows running files with syntax errors in them.
1507 1507
1508 1508 Normally IPython will guess when a file is one of its own logfiles, so
1509 1509 you can typically use %run even for logs. This shorthand allows you to
1510 1510 force any file to be treated as a log file."""
1511 1511
1512 1512 for f in parameter_s.split():
1513 1513 self.shell.safe_execfile(f,self.shell.user_ns,
1514 1514 self.shell.user_ns,islog=1)
1515 1515
1516 1516 def magic_time(self,parameter_s = ''):
1517 1517 """Time execution of a Python statement or expression.
1518 1518
1519 1519 The CPU and wall clock times are printed, and the value of the
1520 1520 expression (if any) is returned. Note that under Win32, system time
1521 1521 is always reported as 0, since it can not be measured.
1522 1522
1523 1523 This function provides very basic timing functionality. In Python
1524 1524 2.3, the timeit module offers more control and sophistication, but for
1525 1525 now IPython supports Python 2.2, so we can not rely on timeit being
1526 1526 present.
1527 1527
1528 1528 Some examples:
1529 1529
1530 1530 In [1]: time 2**128
1531 1531 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1532 1532 Wall time: 0.00
1533 1533 Out[1]: 340282366920938463463374607431768211456L
1534 1534
1535 1535 In [2]: n = 1000000
1536 1536
1537 1537 In [3]: time sum(range(n))
1538 1538 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1539 1539 Wall time: 1.37
1540 1540 Out[3]: 499999500000L
1541 1541
1542 1542 In [4]: time print 'hello world'
1543 1543 hello world
1544 1544 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1545 1545 Wall time: 0.00
1546 1546 """
1547 1547
1548 1548 # fail immediately if the given expression can't be compiled
1549 1549 try:
1550 1550 mode = 'eval'
1551 1551 code = compile(parameter_s,'<timed eval>',mode)
1552 1552 except SyntaxError:
1553 1553 mode = 'exec'
1554 1554 code = compile(parameter_s,'<timed exec>',mode)
1555 1555 # skew measurement as little as possible
1556 1556 glob = self.shell.user_ns
1557 1557 clk = clock2
1558 1558 wtime = time.time
1559 1559 # time execution
1560 1560 wall_st = wtime()
1561 1561 if mode=='eval':
1562 1562 st = clk()
1563 1563 out = eval(code,glob)
1564 1564 end = clk()
1565 1565 else:
1566 1566 st = clk()
1567 1567 exec code in glob
1568 1568 end = clk()
1569 1569 out = None
1570 1570 wall_end = wtime()
1571 1571 # Compute actual times and report
1572 1572 wall_time = wall_end-wall_st
1573 1573 cpu_user = end[0]-st[0]
1574 1574 cpu_sys = end[1]-st[1]
1575 1575 cpu_tot = cpu_user+cpu_sys
1576 1576 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1577 1577 (cpu_user,cpu_sys,cpu_tot)
1578 1578 print "Wall time: %.2f" % wall_time
1579 1579 return out
1580 1580
1581 1581 def magic_macro(self,parameter_s = ''):
1582 1582 """Define a set of input lines as a macro for future re-execution.
1583 1583
1584 1584 Usage:\\
1585 1585 %macro name n1-n2 n3-n4 ... n5 .. n6 ...
1586 1586
1587 1587 This will define a global variable called `name` which is a string
1588 1588 made of joining the slices and lines you specify (n1,n2,... numbers
1589 1589 above) from your input history into a single string. This variable
1590 1590 acts like an automatic function which re-executes those lines as if
1591 1591 you had typed them. You just type 'name' at the prompt and the code
1592 1592 executes.
1593 1593
1594 1594 The notation for indicating number ranges is: n1-n2 means 'use line
1595 1595 numbers n1,...n2' (the endpoint is included). That is, '5-7' means
1596 1596 using the lines numbered 5,6 and 7.
1597 1597
1598 1598 Note: as a 'hidden' feature, you can also use traditional python slice
1599 1599 notation, where N:M means numbers N through M-1.
1600 1600
1601 1601 For example, if your history contains (%hist prints it):
1602 1602
1603 1603 44: x=1\\
1604 1604 45: y=3\\
1605 1605 46: z=x+y\\
1606 1606 47: print x\\
1607 1607 48: a=5\\
1608 1608 49: print 'x',x,'y',y\\
1609 1609
1610 1610 you can create a macro with lines 44 through 47 (included) and line 49
1611 1611 called my_macro with:
1612 1612
1613 1613 In [51]: %macro my_macro 44-47 49
1614 1614
1615 1615 Now, typing `my_macro` (without quotes) will re-execute all this code
1616 1616 in one pass.
1617 1617
1618 1618 You don't need to give the line-numbers in order, and any given line
1619 1619 number can appear multiple times. You can assemble macros with any
1620 1620 lines from your input history in any order.
1621 1621
1622 1622 The macro is a simple object which holds its value in an attribute,
1623 1623 but IPython's display system checks for macros and executes them as
1624 1624 code instead of printing them when you type their name.
1625 1625
1626 1626 You can view a macro's contents by explicitly printing it with:
1627 1627
1628 1628 'print macro_name'.
1629 1629
1630 1630 For one-off cases which DON'T contain magic function calls in them you
1631 1631 can obtain similar results by explicitly executing slices from your
1632 1632 input history with:
1633 1633
1634 1634 In [60]: exec In[44:48]+In[49]"""
1635 1635
1636 1636 args = parameter_s.split()
1637 1637 name,ranges = args[0], args[1:]
1638 1638 #print 'rng',ranges # dbg
1639 1639 lines = self.extract_input_slices(ranges)
1640 1640 macro = Macro(lines)
1641 1641 self.shell.user_ns.update({name:macro})
1642 1642 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
1643 1643 print 'Macro contents:'
1644 1644 print macro,
1645 1645
1646 1646 def magic_save(self,parameter_s = ''):
1647 1647 """Save a set of lines to a given filename.
1648 1648
1649 1649 Usage:\\
1650 1650 %save filename n1-n2 n3-n4 ... n5 .. n6 ...
1651 1651
1652 1652 This function uses the same syntax as %macro for line extraction, but
1653 1653 instead of creating a macro it saves the resulting string to the
1654 1654 filename you specify.
1655 1655
1656 1656 It adds a '.py' extension to the file if you don't do so yourself, and
1657 1657 it asks for confirmation before overwriting existing files."""
1658 1658
1659 1659 args = parameter_s.split()
1660 1660 fname,ranges = args[0], args[1:]
1661 1661 if not fname.endswith('.py'):
1662 1662 fname += '.py'
1663 1663 if os.path.isfile(fname):
1664 1664 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
1665 1665 if ans.lower() not in ['y','yes']:
1666 1666 print 'Operation cancelled.'
1667 1667 return
1668 1668 cmds = ''.join(self.extract_input_slices(ranges))
1669 1669 f = file(fname,'w')
1670 1670 f.write(cmds)
1671 1671 f.close()
1672 1672 print 'The following commands were written to file `%s`:' % fname
1673 1673 print cmds
1674 1674
1675 1675 def _edit_macro(self,mname,macro):
1676 1676 """open an editor with the macro data in a file"""
1677 1677 filename = self.shell.mktempfile(macro.value)
1678 1678 self.shell.hooks.editor(filename)
1679 1679
1680 1680 # and make a new macro object, to replace the old one
1681 1681 mfile = open(filename)
1682 1682 mvalue = mfile.read()
1683 1683 mfile.close()
1684 1684 self.shell.user_ns[mname] = Macro(mvalue)
1685 1685
1686 1686 def magic_ed(self,parameter_s=''):
1687 1687 """Alias to %edit."""
1688 1688 return self.magic_edit(parameter_s)
1689 1689
1690 1690 def magic_edit(self,parameter_s='',last_call=['','']):
1691 1691 """Bring up an editor and execute the resulting code.
1692 1692
1693 1693 Usage:
1694 1694 %edit [options] [args]
1695 1695
1696 1696 %edit runs IPython's editor hook. The default version of this hook is
1697 1697 set to call the __IPYTHON__.rc.editor command. This is read from your
1698 1698 environment variable $EDITOR. If this isn't found, it will default to
1699 1699 vi under Linux/Unix and to notepad under Windows. See the end of this
1700 1700 docstring for how to change the editor hook.
1701 1701
1702 1702 You can also set the value of this editor via the command line option
1703 1703 '-editor' or in your ipythonrc file. This is useful if you wish to use
1704 1704 specifically for IPython an editor different from your typical default
1705 1705 (and for Windows users who typically don't set environment variables).
1706 1706
1707 1707 This command allows you to conveniently edit multi-line code right in
1708 1708 your IPython session.
1709 1709
1710 1710 If called without arguments, %edit opens up an empty editor with a
1711 1711 temporary file and will execute the contents of this file when you
1712 1712 close it (don't forget to save it!).
1713 1713
1714 1714
1715 1715 Options:
1716 1716
1717 1717 -p: this will call the editor with the same data as the previous time
1718 1718 it was used, regardless of how long ago (in your current session) it
1719 1719 was.
1720 1720
1721 1721 -x: do not execute the edited code immediately upon exit. This is
1722 1722 mainly useful if you are editing programs which need to be called with
1723 1723 command line arguments, which you can then do using %run.
1724 1724
1725 1725
1726 1726 Arguments:
1727 1727
1728 1728 If arguments are given, the following possibilites exist:
1729 1729
1730 1730 - The arguments are numbers or pairs of colon-separated numbers (like
1731 1731 1 4:8 9). These are interpreted as lines of previous input to be
1732 1732 loaded into the editor. The syntax is the same of the %macro command.
1733 1733
1734 1734 - If the argument doesn't start with a number, it is evaluated as a
1735 1735 variable and its contents loaded into the editor. You can thus edit
1736 1736 any string which contains python code (including the result of
1737 1737 previous edits).
1738 1738
1739 1739 - If the argument is the name of an object (other than a string),
1740 1740 IPython will try to locate the file where it was defined and open the
1741 1741 editor at the point where it is defined. You can use `%edit function`
1742 1742 to load an editor exactly at the point where 'function' is defined,
1743 1743 edit it and have the file be executed automatically.
1744 1744
1745 1745 If the object is a macro (see %macro for details), this opens up your
1746 1746 specified editor with a temporary file containing the macro's data.
1747 1747 Upon exit, the macro is reloaded with the contents of the file.
1748 1748
1749 1749 Note: opening at an exact line is only supported under Unix, and some
1750 1750 editors (like kedit and gedit up to Gnome 2.8) do not understand the
1751 1751 '+NUMBER' parameter necessary for this feature. Good editors like
1752 1752 (X)Emacs, vi, jed, pico and joe all do.
1753 1753
1754 1754 - If the argument is not found as a variable, IPython will look for a
1755 1755 file with that name (adding .py if necessary) and load it into the
1756 1756 editor. It will execute its contents with execfile() when you exit,
1757 1757 loading any code in the file into your interactive namespace.
1758 1758
1759 1759 After executing your code, %edit will return as output the code you
1760 1760 typed in the editor (except when it was an existing file). This way
1761 1761 you can reload the code in further invocations of %edit as a variable,
1762 1762 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
1763 1763 the output.
1764 1764
1765 1765 Note that %edit is also available through the alias %ed.
1766 1766
1767 1767 This is an example of creating a simple function inside the editor and
1768 1768 then modifying it. First, start up the editor:
1769 1769
1770 1770 In [1]: ed\\
1771 1771 Editing... done. Executing edited code...\\
1772 1772 Out[1]: 'def foo():\\n print "foo() was defined in an editing session"\\n'
1773 1773
1774 1774 We can then call the function foo():
1775 1775
1776 1776 In [2]: foo()\\
1777 1777 foo() was defined in an editing session
1778 1778
1779 1779 Now we edit foo. IPython automatically loads the editor with the
1780 1780 (temporary) file where foo() was previously defined:
1781 1781
1782 1782 In [3]: ed foo\\
1783 1783 Editing... done. Executing edited code...
1784 1784
1785 1785 And if we call foo() again we get the modified version:
1786 1786
1787 1787 In [4]: foo()\\
1788 1788 foo() has now been changed!
1789 1789
1790 1790 Here is an example of how to edit a code snippet successive
1791 1791 times. First we call the editor:
1792 1792
1793 1793 In [8]: ed\\
1794 1794 Editing... done. Executing edited code...\\
1795 1795 hello\\
1796 1796 Out[8]: "print 'hello'\\n"
1797 1797
1798 1798 Now we call it again with the previous output (stored in _):
1799 1799
1800 1800 In [9]: ed _\\
1801 1801 Editing... done. Executing edited code...\\
1802 1802 hello world\\
1803 1803 Out[9]: "print 'hello world'\\n"
1804 1804
1805 1805 Now we call it with the output #8 (stored in _8, also as Out[8]):
1806 1806
1807 1807 In [10]: ed _8\\
1808 1808 Editing... done. Executing edited code...\\
1809 1809 hello again\\
1810 1810 Out[10]: "print 'hello again'\\n"
1811 1811
1812 1812
1813 1813 Changing the default editor hook:
1814 1814
1815 1815 If you wish to write your own editor hook, you can put it in a
1816 1816 configuration file which you load at startup time. The default hook
1817 1817 is defined in the IPython.hooks module, and you can use that as a
1818 1818 starting example for further modifications. That file also has
1819 1819 general instructions on how to set a new hook for use once you've
1820 1820 defined it."""
1821 1821
1822 1822 # FIXME: This function has become a convoluted mess. It needs a
1823 1823 # ground-up rewrite with clean, simple logic.
1824 1824
1825 1825 def make_filename(arg):
1826 1826 "Make a filename from the given args"
1827 1827 try:
1828 1828 filename = get_py_filename(arg)
1829 1829 except IOError:
1830 1830 if args.endswith('.py'):
1831 1831 filename = arg
1832 1832 else:
1833 1833 filename = None
1834 1834 return filename
1835 1835
1836 1836 # custom exceptions
1837 1837 class DataIsObject(Exception): pass
1838 1838
1839 1839 opts,args = self.parse_options(parameter_s,'px')
1840 1840
1841 1841 # Default line number value
1842 1842 lineno = None
1843 1843 if opts.has_key('p'):
1844 1844 args = '_%s' % last_call[0]
1845 1845 if not self.shell.user_ns.has_key(args):
1846 1846 args = last_call[1]
1847 1847
1848 1848 # use last_call to remember the state of the previous call, but don't
1849 1849 # let it be clobbered by successive '-p' calls.
1850 1850 try:
1851 1851 last_call[0] = self.shell.outputcache.prompt_count
1852 1852 if not opts.has_key('p'):
1853 1853 last_call[1] = parameter_s
1854 1854 except:
1855 1855 pass
1856 1856
1857 1857 # by default this is done with temp files, except when the given
1858 1858 # arg is a filename
1859 1859 use_temp = 1
1860 1860
1861 1861 if re.match(r'\d',args):
1862 1862 # Mode where user specifies ranges of lines, like in %macro.
1863 1863 # This means that you can't edit files whose names begin with
1864 1864 # numbers this way. Tough.
1865 1865 ranges = args.split()
1866 1866 data = ''.join(self.extract_input_slices(ranges))
1867 1867 elif args.endswith('.py'):
1868 1868 filename = make_filename(args)
1869 1869 data = ''
1870 1870 use_temp = 0
1871 1871 elif args:
1872 1872 try:
1873 1873 # Load the parameter given as a variable. If not a string,
1874 1874 # process it as an object instead (below)
1875 1875
1876 1876 #print '*** args',args,'type',type(args) # dbg
1877 1877 data = eval(args,self.shell.user_ns)
1878 1878 if not type(data) in StringTypes:
1879 1879 raise DataIsObject
1880 1880
1881 1881 except (NameError,SyntaxError):
1882 1882 # given argument is not a variable, try as a filename
1883 1883 filename = make_filename(args)
1884 1884 if filename is None:
1885 1885 warn("Argument given (%s) can't be found as a variable "
1886 1886 "or as a filename." % args)
1887 1887 return
1888 1888
1889 1889 data = ''
1890 1890 use_temp = 0
1891 1891 except DataIsObject:
1892 1892
1893 1893 # macros have a special edit function
1894 1894 if isinstance(data,Macro):
1895 1895 self._edit_macro(args,data)
1896 1896 return
1897 1897
1898 1898 # For objects, try to edit the file where they are defined
1899 1899 try:
1900 1900 filename = inspect.getabsfile(data)
1901 1901 datafile = 1
1902 1902 except TypeError:
1903 1903 filename = make_filename(args)
1904 1904 datafile = 1
1905 1905 warn('Could not find file where `%s` is defined.\n'
1906 1906 'Opening a file named `%s`' % (args,filename))
1907 1907 # Now, make sure we can actually read the source (if it was in
1908 1908 # a temp file it's gone by now).
1909 1909 if datafile:
1910 1910 try:
1911 1911 lineno = inspect.getsourcelines(data)[1]
1912 1912 except IOError:
1913 1913 filename = make_filename(args)
1914 1914 if filename is None:
1915 1915 warn('The file `%s` where `%s` was defined cannot '
1916 1916 'be read.' % (filename,data))
1917 1917 return
1918 1918 use_temp = 0
1919 1919 else:
1920 1920 data = ''
1921 1921
1922 1922 if use_temp:
1923 1923 filename = self.shell.mktempfile(data)
1924 1924 print 'IPython will make a temporary file named:',filename
1925 1925
1926 1926 # do actual editing here
1927 1927 print 'Editing...',
1928 1928 sys.stdout.flush()
1929 1929 self.shell.hooks.editor(filename,lineno)
1930 1930 if opts.has_key('x'): # -x prevents actual execution
1931 1931 print
1932 1932 else:
1933 1933 print 'done. Executing edited code...'
1934 1934 try:
1935 1935 self.shell.safe_execfile(filename,self.shell.user_ns)
1936 1936 except IOError,msg:
1937 1937 if msg.filename == filename:
1938 1938 warn('File not found. Did you forget to save?')
1939 1939 return
1940 1940 else:
1941 1941 self.shell.showtraceback()
1942 1942 except:
1943 1943 self.shell.showtraceback()
1944 1944
1945 1945 def magic_xmode(self,parameter_s = ''):
1946 1946 """Switch modes for the exception handlers.
1947 1947
1948 1948 Valid modes: Plain, Context and Verbose.
1949 1949
1950 1950 If called without arguments, acts as a toggle."""
1951 1951
1952 1952 def xmode_switch_err(name):
1953 1953 warn('Error changing %s exception modes.\n%s' %
1954 1954 (name,sys.exc_info()[1]))
1955 1955
1956 1956 shell = self.shell
1957 1957 new_mode = parameter_s.strip().capitalize()
1958 1958 try:
1959 1959 shell.InteractiveTB.set_mode(mode=new_mode)
1960 1960 print 'Exception reporting mode:',shell.InteractiveTB.mode
1961 1961 except:
1962 1962 xmode_switch_err('user')
1963 1963
1964 1964 # threaded shells use a special handler in sys.excepthook
1965 1965 if shell.isthreaded:
1966 1966 try:
1967 1967 shell.sys_excepthook.set_mode(mode=new_mode)
1968 1968 except:
1969 1969 xmode_switch_err('threaded')
1970 1970
1971 1971 def magic_colors(self,parameter_s = ''):
1972 1972 """Switch color scheme for prompts, info system and exception handlers.
1973 1973
1974 1974 Currently implemented schemes: NoColor, Linux, LightBG.
1975 1975
1976 1976 Color scheme names are not case-sensitive."""
1977 1977
1978 1978 def color_switch_err(name):
1979 1979 warn('Error changing %s color schemes.\n%s' %
1980 1980 (name,sys.exc_info()[1]))
1981 1981
1982 1982
1983 1983 new_scheme = parameter_s.strip()
1984 1984 if not new_scheme:
1985 1985 print 'You must specify a color scheme.'
1986 1986 return
1987 1987 # Under Windows, check for Gary Bishop's readline, which is necessary
1988 1988 # for ANSI coloring
1989 1989 if os.name in ['nt','dos']:
1990 1990 try:
1991 1991 import readline
1992 1992 except ImportError:
1993 1993 has_readline = 0
1994 1994 else:
1995 1995 try:
1996 1996 readline.GetOutputFile()
1997 1997 except AttributeError:
1998 1998 has_readline = 0
1999 1999 else:
2000 2000 has_readline = 1
2001 2001 if not has_readline:
2002 2002 msg = """\
2003 2003 Proper color support under MS Windows requires Gary Bishop's readline library.
2004 2004 You can find it at:
2005 2005 http://sourceforge.net/projects/uncpythontools
2006 2006 Gary's readline needs the ctypes module, from:
2007 2007 http://starship.python.net/crew/theller/ctypes
2008 2008
2009 2009 Defaulting color scheme to 'NoColor'"""
2010 2010 new_scheme = 'NoColor'
2011 2011 warn(msg)
2012 2012 # local shortcut
2013 2013 shell = self.shell
2014 2014
2015 2015 # Set prompt colors
2016 2016 try:
2017 2017 shell.outputcache.set_colors(new_scheme)
2018 2018 except:
2019 2019 color_switch_err('prompt')
2020 2020 else:
2021 2021 shell.rc.colors = \
2022 2022 shell.outputcache.color_table.active_scheme_name
2023 2023 # Set exception colors
2024 2024 try:
2025 2025 shell.InteractiveTB.set_colors(scheme = new_scheme)
2026 2026 shell.SyntaxTB.set_colors(scheme = new_scheme)
2027 2027 except:
2028 2028 color_switch_err('exception')
2029 2029
2030 2030 # threaded shells use a verbose traceback in sys.excepthook
2031 2031 if shell.isthreaded:
2032 2032 try:
2033 2033 shell.sys_excepthook.set_colors(scheme=new_scheme)
2034 2034 except:
2035 2035 color_switch_err('system exception handler')
2036 2036
2037 2037 # Set info (for 'object?') colors
2038 2038 if shell.rc.color_info:
2039 2039 try:
2040 2040 shell.inspector.set_active_scheme(new_scheme)
2041 2041 except:
2042 2042 color_switch_err('object inspector')
2043 2043 else:
2044 2044 shell.inspector.set_active_scheme('NoColor')
2045 2045
2046 2046 def magic_color_info(self,parameter_s = ''):
2047 2047 """Toggle color_info.
2048 2048
2049 2049 The color_info configuration parameter controls whether colors are
2050 2050 used for displaying object details (by things like %psource, %pfile or
2051 2051 the '?' system). This function toggles this value with each call.
2052 2052
2053 2053 Note that unless you have a fairly recent pager (less works better
2054 2054 than more) in your system, using colored object information displays
2055 2055 will not work properly. Test it and see."""
2056 2056
2057 2057 self.shell.rc.color_info = 1 - self.shell.rc.color_info
2058 2058 self.magic_colors(self.shell.rc.colors)
2059 2059 print 'Object introspection functions have now coloring:',
2060 2060 print ['OFF','ON'][self.shell.rc.color_info]
2061 2061
2062 2062 def magic_Pprint(self, parameter_s=''):
2063 2063 """Toggle pretty printing on/off."""
2064 2064
2065 2065 self.shell.outputcache.Pprint = 1 - self.shell.outputcache.Pprint
2066 2066 print 'Pretty printing has been turned', \
2067 2067 ['OFF','ON'][self.shell.outputcache.Pprint]
2068 2068
2069 2069 def magic_exit(self, parameter_s=''):
2070 2070 """Exit IPython, confirming if configured to do so.
2071 2071
2072 2072 You can configure whether IPython asks for confirmation upon exit by
2073 2073 setting the confirm_exit flag in the ipythonrc file."""
2074 2074
2075 2075 self.shell.exit()
2076 2076
2077 2077 def magic_quit(self, parameter_s=''):
2078 2078 """Exit IPython, confirming if configured to do so (like %exit)"""
2079 2079
2080 2080 self.shell.exit()
2081 2081
2082 2082 def magic_Exit(self, parameter_s=''):
2083 2083 """Exit IPython without confirmation."""
2084 2084
2085 2085 self.shell.exit_now = True
2086 2086
2087 2087 def magic_Quit(self, parameter_s=''):
2088 2088 """Exit IPython without confirmation (like %Exit)."""
2089 2089
2090 2090 self.shell.exit_now = True
2091 2091
2092 2092 #......................................................................
2093 2093 # Functions to implement unix shell-type things
2094 2094
2095 2095 def magic_alias(self, parameter_s = ''):
2096 2096 """Define an alias for a system command.
2097 2097
2098 2098 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2099 2099
2100 2100 Then, typing 'alias_name params' will execute the system command 'cmd
2101 2101 params' (from your underlying operating system).
2102 2102
2103 2103 Aliases have lower precedence than magic functions and Python normal
2104 2104 variables, so if 'foo' is both a Python variable and an alias, the
2105 2105 alias can not be executed until 'del foo' removes the Python variable.
2106 2106
2107 2107 You can use the %l specifier in an alias definition to represent the
2108 2108 whole line when the alias is called. For example:
2109 2109
2110 2110 In [2]: alias all echo "Input in brackets: <%l>"\\
2111 2111 In [3]: all hello world\\
2112 2112 Input in brackets: <hello world>
2113 2113
2114 2114 You can also define aliases with parameters using %s specifiers (one
2115 2115 per parameter):
2116 2116
2117 2117 In [1]: alias parts echo first %s second %s\\
2118 2118 In [2]: %parts A B\\
2119 2119 first A second B\\
2120 2120 In [3]: %parts A\\
2121 2121 Incorrect number of arguments: 2 expected.\\
2122 2122 parts is an alias to: 'echo first %s second %s'
2123 2123
2124 2124 Note that %l and %s are mutually exclusive. You can only use one or
2125 2125 the other in your aliases.
2126 2126
2127 2127 Aliases expand Python variables just like system calls using ! or !!
2128 2128 do: all expressions prefixed with '$' get expanded. For details of
2129 2129 the semantic rules, see PEP-215:
2130 2130 http://www.python.org/peps/pep-0215.html. This is the library used by
2131 2131 IPython for variable expansion. If you want to access a true shell
2132 2132 variable, an extra $ is necessary to prevent its expansion by IPython:
2133 2133
2134 2134 In [6]: alias show echo\\
2135 2135 In [7]: PATH='A Python string'\\
2136 2136 In [8]: show $PATH\\
2137 2137 A Python string\\
2138 2138 In [9]: show $$PATH\\
2139 2139 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2140 2140
2141 2141 You can use the alias facility to acess all of $PATH. See the %rehash
2142 2142 and %rehashx functions, which automatically create aliases for the
2143 2143 contents of your $PATH.
2144 2144
2145 2145 If called with no parameters, %alias prints the current alias table."""
2146 2146
2147 2147 par = parameter_s.strip()
2148 2148 if not par:
2149 2149 if self.shell.rc.automagic:
2150 2150 prechar = ''
2151 2151 else:
2152 2152 prechar = self.shell.ESC_MAGIC
2153 2153 print 'Alias\t\tSystem Command\n'+'-'*30
2154 2154 atab = self.shell.alias_table
2155 2155 aliases = atab.keys()
2156 2156 aliases.sort()
2157 2157 for alias in aliases:
2158 2158 print prechar+alias+'\t\t'+atab[alias][1]
2159 2159 print '-'*30+'\nTotal number of aliases:',len(aliases)
2160 2160 return
2161 2161 try:
2162 2162 alias,cmd = par.split(None,1)
2163 2163 except:
2164 2164 print OInspect.getdoc(self.magic_alias)
2165 2165 else:
2166 2166 nargs = cmd.count('%s')
2167 2167 if nargs>0 and cmd.find('%l')>=0:
2168 2168 error('The %s and %l specifiers are mutually exclusive '
2169 2169 'in alias definitions.')
2170 2170 else: # all looks OK
2171 2171 self.shell.alias_table[alias] = (nargs,cmd)
2172 2172 self.shell.alias_table_validate(verbose=1)
2173 2173 # end magic_alias
2174 2174
2175 2175 def magic_unalias(self, parameter_s = ''):
2176 2176 """Remove an alias"""
2177 2177
2178 2178 aname = parameter_s.strip()
2179 2179 if aname in self.shell.alias_table:
2180 2180 del self.shell.alias_table[aname]
2181 2181
2182 2182 def magic_rehash(self, parameter_s = ''):
2183 2183 """Update the alias table with all entries in $PATH.
2184 2184
2185 2185 This version does no checks on execute permissions or whether the
2186 2186 contents of $PATH are truly files (instead of directories or something
2187 2187 else). For such a safer (but slower) version, use %rehashx."""
2188 2188
2189 2189 # This function (and rehashx) manipulate the alias_table directly
2190 2190 # rather than calling magic_alias, for speed reasons. A rehash on a
2191 2191 # typical Linux box involves several thousand entries, so efficiency
2192 2192 # here is a top concern.
2193 2193
2194 2194 path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
2195 2195 alias_table = self.shell.alias_table
2196 2196 for pdir in path:
2197 2197 for ff in os.listdir(pdir):
2198 2198 # each entry in the alias table must be (N,name), where
2199 2199 # N is the number of positional arguments of the alias.
2200 2200 alias_table[ff] = (0,ff)
2201 2201 # Make sure the alias table doesn't contain keywords or builtins
2202 2202 self.shell.alias_table_validate()
2203 2203 # Call again init_auto_alias() so we get 'rm -i' and other modified
2204 2204 # aliases since %rehash will probably clobber them
2205 2205 self.shell.init_auto_alias()
2206 2206
2207 2207 def magic_rehashx(self, parameter_s = ''):
2208 2208 """Update the alias table with all executable files in $PATH.
2209 2209
2210 2210 This version explicitly checks that every entry in $PATH is a file
2211 2211 with execute access (os.X_OK), so it is much slower than %rehash.
2212 2212
2213 2213 Under Windows, it checks executability as a match agains a
2214 2214 '|'-separated string of extensions, stored in the IPython config
2215 2215 variable win_exec_ext. This defaults to 'exe|com|bat'. """
2216 2216
2217 2217 path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
2218 2218 alias_table = self.shell.alias_table
2219 2219
2220 2220 if os.name == 'posix':
2221 2221 isexec = lambda fname:os.path.isfile(fname) and \
2222 2222 os.access(fname,os.X_OK)
2223 2223 else:
2224 2224
2225 2225 try:
2226 2226 winext = os.environ['pathext'].replace(';','|').replace('.','')
2227 2227 except KeyError:
2228 2228 winext = 'exe|com|bat'
2229 2229
2230 2230 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2231 2231 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2232 2232 savedir = os.getcwd()
2233 2233 try:
2234 2234 # write the whole loop for posix/Windows so we don't have an if in
2235 2235 # the innermost part
2236 2236 if os.name == 'posix':
2237 2237 for pdir in path:
2238 2238 os.chdir(pdir)
2239 2239 for ff in os.listdir(pdir):
2240 2240 if isexec(ff):
2241 2241 # each entry in the alias table must be (N,name),
2242 2242 # where N is the number of positional arguments of the
2243 2243 # alias.
2244 2244 alias_table[ff] = (0,ff)
2245 2245 else:
2246 2246 for pdir in path:
2247 2247 os.chdir(pdir)
2248 2248 for ff in os.listdir(pdir):
2249 2249 if isexec(ff):
2250 2250 alias_table[execre.sub(r'\1',ff)] = (0,ff)
2251 2251 # Make sure the alias table doesn't contain keywords or builtins
2252 2252 self.shell.alias_table_validate()
2253 2253 # Call again init_auto_alias() so we get 'rm -i' and other
2254 2254 # modified aliases since %rehashx will probably clobber them
2255 2255 self.shell.init_auto_alias()
2256 2256 finally:
2257 2257 os.chdir(savedir)
2258 2258
2259 2259 def magic_pwd(self, parameter_s = ''):
2260 2260 """Return the current working directory path."""
2261 2261 return os.getcwd()
2262 2262
2263 2263 def magic_cd(self, parameter_s=''):
2264 2264 """Change the current working directory.
2265 2265
2266 2266 This command automatically maintains an internal list of directories
2267 2267 you visit during your IPython session, in the variable _dh. The
2268 2268 command %dhist shows this history nicely formatted.
2269 2269
2270 2270 Usage:
2271 2271
2272 2272 cd 'dir': changes to directory 'dir'.
2273 2273
2274 2274 cd -: changes to the last visited directory.
2275 2275
2276 2276 cd -<n>: changes to the n-th directory in the directory history.
2277 2277
2278 2278 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2279 2279 (note: cd <bookmark_name> is enough if there is no
2280 2280 directory <bookmark_name>, but a bookmark with the name exists.)
2281 2281
2282 2282 Options:
2283 2283
2284 2284 -q: quiet. Do not print the working directory after the cd command is
2285 2285 executed. By default IPython's cd command does print this directory,
2286 2286 since the default prompts do not display path information.
2287 2287
2288 2288 Note that !cd doesn't work for this purpose because the shell where
2289 2289 !command runs is immediately discarded after executing 'command'."""
2290 2290
2291 2291 parameter_s = parameter_s.strip()
2292 2292 bkms = self.shell.persist.get("bookmarks",{})
2293 2293
2294 2294 numcd = re.match(r'(-)(\d+)$',parameter_s)
2295 2295 # jump in directory history by number
2296 2296 if numcd:
2297 2297 nn = int(numcd.group(2))
2298 2298 try:
2299 2299 ps = self.shell.user_ns['_dh'][nn]
2300 2300 except IndexError:
2301 2301 print 'The requested directory does not exist in history.'
2302 2302 return
2303 2303 else:
2304 2304 opts = {}
2305 2305 else:
2306 2306 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2307 2307 # jump to previous
2308 2308 if ps == '-':
2309 2309 try:
2310 2310 ps = self.shell.user_ns['_dh'][-2]
2311 2311 except IndexError:
2312 2312 print 'No previous directory to change to.'
2313 2313 return
2314 2314 # jump to bookmark
2315 2315 elif opts.has_key('b') or (bkms.has_key(ps) and not os.path.isdir(ps)):
2316 2316 if bkms.has_key(ps):
2317 2317 target = bkms[ps]
2318 2318 print '(bookmark:%s) -> %s' % (ps,target)
2319 2319 ps = target
2320 2320 else:
2321 2321 if bkms:
2322 2322 error("Bookmark '%s' not found. "
2323 2323 "Use '%%bookmark -l' to see your bookmarks." % ps)
2324 2324 else:
2325 2325 print "Bookmarks not set - use %bookmark <bookmarkname>"
2326 2326 return
2327 2327
2328 2328 # at this point ps should point to the target dir
2329 2329 if ps:
2330 2330 try:
2331 2331 os.chdir(os.path.expanduser(ps))
2332 ttitle = ("IPy:" + (
2333 os.getcwd() == '/' and '/' or os.path.basename(os.getcwd())))
2334 platutils.set_term_title(ttitle)
2332 2335 except OSError:
2333 2336 print sys.exc_info()[1]
2334 2337 else:
2335 2338 self.shell.user_ns['_dh'].append(os.getcwd())
2336 2339 else:
2337 2340 os.chdir(self.shell.home_dir)
2341 platutils.set_term_title("IPy:~")
2338 2342 self.shell.user_ns['_dh'].append(os.getcwd())
2339 2343 if not 'q' in opts:
2340 2344 print self.shell.user_ns['_dh'][-1]
2341 2345
2342 2346 def magic_dhist(self, parameter_s=''):
2343 2347 """Print your history of visited directories.
2344 2348
2345 2349 %dhist -> print full history\\
2346 2350 %dhist n -> print last n entries only\\
2347 2351 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2348 2352
2349 2353 This history is automatically maintained by the %cd command, and
2350 2354 always available as the global list variable _dh. You can use %cd -<n>
2351 2355 to go to directory number <n>."""
2352 2356
2353 2357 dh = self.shell.user_ns['_dh']
2354 2358 if parameter_s:
2355 2359 try:
2356 2360 args = map(int,parameter_s.split())
2357 2361 except:
2358 2362 self.arg_err(Magic.magic_dhist)
2359 2363 return
2360 2364 if len(args) == 1:
2361 2365 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2362 2366 elif len(args) == 2:
2363 2367 ini,fin = args
2364 2368 else:
2365 2369 self.arg_err(Magic.magic_dhist)
2366 2370 return
2367 2371 else:
2368 2372 ini,fin = 0,len(dh)
2369 2373 nlprint(dh,
2370 2374 header = 'Directory history (kept in _dh)',
2371 2375 start=ini,stop=fin)
2372 2376
2373 2377 def magic_env(self, parameter_s=''):
2374 2378 """List environment variables."""
2375 2379
2376 2380 return os.environ.data
2377 2381
2378 2382 def magic_pushd(self, parameter_s=''):
2379 2383 """Place the current dir on stack and change directory.
2380 2384
2381 2385 Usage:\\
2382 2386 %pushd ['dirname']
2383 2387
2384 2388 %pushd with no arguments does a %pushd to your home directory.
2385 2389 """
2386 2390 if parameter_s == '': parameter_s = '~'
2387 2391 dir_s = self.shell.dir_stack
2388 2392 if len(dir_s)>0 and os.path.expanduser(parameter_s) != \
2389 2393 os.path.expanduser(self.shell.dir_stack[0]):
2390 2394 try:
2391 2395 self.magic_cd(parameter_s)
2392 2396 dir_s.insert(0,os.getcwd().replace(self.home_dir,'~'))
2393 2397 self.magic_dirs()
2394 2398 except:
2395 2399 print 'Invalid directory'
2396 2400 else:
2397 2401 print 'You are already there!'
2398 2402
2399 2403 def magic_popd(self, parameter_s=''):
2400 2404 """Change to directory popped off the top of the stack.
2401 2405 """
2402 2406 if len (self.shell.dir_stack) > 1:
2403 2407 self.shell.dir_stack.pop(0)
2404 2408 self.magic_cd(self.shell.dir_stack[0])
2405 2409 print self.shell.dir_stack[0]
2406 2410 else:
2407 2411 print "You can't remove the starting directory from the stack:",\
2408 2412 self.shell.dir_stack
2409 2413
2410 2414 def magic_dirs(self, parameter_s=''):
2411 2415 """Return the current directory stack."""
2412 2416
2413 2417 return self.shell.dir_stack[:]
2414 2418
2415 2419 def magic_sc(self, parameter_s=''):
2416 2420 """Shell capture - execute a shell command and capture its output.
2417 2421
2418 2422 %sc [options] varname=command
2419 2423
2420 2424 IPython will run the given command using commands.getoutput(), and
2421 2425 will then update the user's interactive namespace with a variable
2422 2426 called varname, containing the value of the call. Your command can
2423 2427 contain shell wildcards, pipes, etc.
2424 2428
2425 2429 The '=' sign in the syntax is mandatory, and the variable name you
2426 2430 supply must follow Python's standard conventions for valid names.
2427 2431
2428 2432 Options:
2429 2433
2430 2434 -l: list output. Split the output on newlines into a list before
2431 2435 assigning it to the given variable. By default the output is stored
2432 2436 as a single string.
2433 2437
2434 2438 -v: verbose. Print the contents of the variable.
2435 2439
2436 2440 In most cases you should not need to split as a list, because the
2437 2441 returned value is a special type of string which can automatically
2438 2442 provide its contents either as a list (split on newlines) or as a
2439 2443 space-separated string. These are convenient, respectively, either
2440 2444 for sequential processing or to be passed to a shell command.
2441 2445
2442 2446 For example:
2443 2447
2444 2448 # Capture into variable a
2445 2449 In [9]: sc a=ls *py
2446 2450
2447 2451 # a is a string with embedded newlines
2448 2452 In [10]: a
2449 2453 Out[10]: 'setup.py\nwin32_manual_post_install.py'
2450 2454
2451 2455 # which can be seen as a list:
2452 2456 In [11]: a.l
2453 2457 Out[11]: ['setup.py', 'win32_manual_post_install.py']
2454 2458
2455 2459 # or as a whitespace-separated string:
2456 2460 In [12]: a.s
2457 2461 Out[12]: 'setup.py win32_manual_post_install.py'
2458 2462
2459 2463 # a.s is useful to pass as a single command line:
2460 2464 In [13]: !wc -l $a.s
2461 2465 146 setup.py
2462 2466 130 win32_manual_post_install.py
2463 2467 276 total
2464 2468
2465 2469 # while the list form is useful to loop over:
2466 2470 In [14]: for f in a.l:
2467 2471 ....: !wc -l $f
2468 2472 ....:
2469 2473 146 setup.py
2470 2474 130 win32_manual_post_install.py
2471 2475
2472 2476 Similiarly, the lists returned by the -l option are also special, in
2473 2477 the sense that you can equally invoke the .s attribute on them to
2474 2478 automatically get a whitespace-separated string from their contents:
2475 2479
2476 2480 In [1]: sc -l b=ls *py
2477 2481
2478 2482 In [2]: b
2479 2483 Out[2]: ['setup.py', 'win32_manual_post_install.py']
2480 2484
2481 2485 In [3]: b.s
2482 2486 Out[3]: 'setup.py win32_manual_post_install.py'
2483 2487
2484 2488 In summary, both the lists and strings used for ouptut capture have
2485 2489 the following special attributes:
2486 2490
2487 2491 .l (or .list) : value as list.
2488 2492 .n (or .nlstr): value as newline-separated string.
2489 2493 .s (or .spstr): value as space-separated string.
2490 2494 """
2491 2495
2492 2496 opts,args = self.parse_options(parameter_s,'lv')
2493 2497 # Try to get a variable name and command to run
2494 2498 try:
2495 2499 # the variable name must be obtained from the parse_options
2496 2500 # output, which uses shlex.split to strip options out.
2497 2501 var,_ = args.split('=',1)
2498 2502 var = var.strip()
2499 2503 # But the the command has to be extracted from the original input
2500 2504 # parameter_s, not on what parse_options returns, to avoid the
2501 2505 # quote stripping which shlex.split performs on it.
2502 2506 _,cmd = parameter_s.split('=',1)
2503 2507 except ValueError:
2504 2508 var,cmd = '',''
2505 2509 if not var:
2506 2510 error('you must specify a variable to assign the command to.')
2507 2511 return
2508 2512 # If all looks ok, proceed
2509 2513 out,err = self.shell.getoutputerror(cmd)
2510 2514 if err:
2511 2515 print >> Term.cerr,err
2512 2516 if opts.has_key('l'):
2513 2517 out = SList(out.split('\n'))
2514 2518 else:
2515 2519 out = LSString(out)
2516 2520 if opts.has_key('v'):
2517 2521 print '%s ==\n%s' % (var,pformat(out))
2518 2522 self.shell.user_ns.update({var:out})
2519 2523
2520 2524 def magic_sx(self, parameter_s=''):
2521 2525 """Shell execute - run a shell command and capture its output.
2522 2526
2523 2527 %sx command
2524 2528
2525 2529 IPython will run the given command using commands.getoutput(), and
2526 2530 return the result formatted as a list (split on '\\n'). Since the
2527 2531 output is _returned_, it will be stored in ipython's regular output
2528 2532 cache Out[N] and in the '_N' automatic variables.
2529 2533
2530 2534 Notes:
2531 2535
2532 2536 1) If an input line begins with '!!', then %sx is automatically
2533 2537 invoked. That is, while:
2534 2538 !ls
2535 2539 causes ipython to simply issue system('ls'), typing
2536 2540 !!ls
2537 2541 is a shorthand equivalent to:
2538 2542 %sx ls
2539 2543
2540 2544 2) %sx differs from %sc in that %sx automatically splits into a list,
2541 2545 like '%sc -l'. The reason for this is to make it as easy as possible
2542 2546 to process line-oriented shell output via further python commands.
2543 2547 %sc is meant to provide much finer control, but requires more
2544 2548 typing.
2545 2549
2546 2550 3) Just like %sc -l, this is a list with special attributes:
2547 2551
2548 2552 .l (or .list) : value as list.
2549 2553 .n (or .nlstr): value as newline-separated string.
2550 2554 .s (or .spstr): value as whitespace-separated string.
2551 2555
2552 2556 This is very useful when trying to use such lists as arguments to
2553 2557 system commands."""
2554 2558
2555 2559 if parameter_s:
2556 2560 out,err = self.shell.getoutputerror(parameter_s)
2557 2561 if err:
2558 2562 print >> Term.cerr,err
2559 2563 return SList(out.split('\n'))
2560 2564
2561 2565 def magic_bg(self, parameter_s=''):
2562 2566 """Run a job in the background, in a separate thread.
2563 2567
2564 2568 For example,
2565 2569
2566 2570 %bg myfunc(x,y,z=1)
2567 2571
2568 2572 will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
2569 2573 execution starts, a message will be printed indicating the job
2570 2574 number. If your job number is 5, you can use
2571 2575
2572 2576 myvar = jobs.result(5) or myvar = jobs[5].result
2573 2577
2574 2578 to assign this result to variable 'myvar'.
2575 2579
2576 2580 IPython has a job manager, accessible via the 'jobs' object. You can
2577 2581 type jobs? to get more information about it, and use jobs.<TAB> to see
2578 2582 its attributes. All attributes not starting with an underscore are
2579 2583 meant for public use.
2580 2584
2581 2585 In particular, look at the jobs.new() method, which is used to create
2582 2586 new jobs. This magic %bg function is just a convenience wrapper
2583 2587 around jobs.new(), for expression-based jobs. If you want to create a
2584 2588 new job with an explicit function object and arguments, you must call
2585 2589 jobs.new() directly.
2586 2590
2587 2591 The jobs.new docstring also describes in detail several important
2588 2592 caveats associated with a thread-based model for background job
2589 2593 execution. Type jobs.new? for details.
2590 2594
2591 2595 You can check the status of all jobs with jobs.status().
2592 2596
2593 2597 The jobs variable is set by IPython into the Python builtin namespace.
2594 2598 If you ever declare a variable named 'jobs', you will shadow this
2595 2599 name. You can either delete your global jobs variable to regain
2596 2600 access to the job manager, or make a new name and assign it manually
2597 2601 to the manager (stored in IPython's namespace). For example, to
2598 2602 assign the job manager to the Jobs name, use:
2599 2603
2600 2604 Jobs = __builtins__.jobs"""
2601 2605
2602 2606 self.shell.jobs.new(parameter_s,self.shell.user_ns)
2603 2607
2604 2608 def magic_store(self, parameter_s=''):
2605 2609 """Lightweight persistence for python variables.
2606 2610
2607 2611 Example:
2608 2612
2609 2613 ville@badger[~]|1> A = ['hello',10,'world']\\
2610 2614 ville@badger[~]|2> %store A\\
2611 2615 ville@badger[~]|3> Exit
2612 2616
2613 2617 (IPython session is closed and started again...)
2614 2618
2615 2619 ville@badger:~$ ipython -p pysh\\
2616 2620 ville@badger[~]|1> print A
2617 2621
2618 2622 ['hello', 10, 'world']
2619 2623
2620 2624 Usage:
2621 2625
2622 2626 %store - Show list of all variables and their current values\\
2623 2627 %store <var> - Store the *current* value of the variable to disk\\
2624 2628 %store -d <var> - Remove the variable and its value from storage\\
2625 2629 %store -r - Remove all variables from storage
2626 2630
2627 2631 It should be noted that if you change the value of a variable, you
2628 2632 need to %store it again if you want to persist the new value.
2629 2633
2630 2634 Note also that the variables will need to be pickleable; most basic
2631 2635 python types can be safely %stored.
2632 2636 """
2633 2637
2634 2638 opts,args = self.parse_options(parameter_s,'dr',mode='list')
2635 2639 # delete
2636 2640 if opts.has_key('d'):
2637 2641 try:
2638 2642 todel = args[0]
2639 2643 except IndexError:
2640 2644 error('You must provide the variable to forget')
2641 2645 else:
2642 2646 try:
2643 2647 del self.shell.persist['S:' + todel]
2644 2648 except:
2645 2649 error("Can't delete variable '%s'" % todel)
2646 2650 # reset
2647 2651 elif opts.has_key('r'):
2648 2652 for k in self.shell.persist.keys():
2649 2653 if k.startswith('S:'):
2650 2654 del self.shell.persist[k]
2651 2655
2652 2656 # run without arguments -> list variables & values
2653 2657 elif not args:
2654 2658 vars = [v[2:] for v in self.shell.persist.keys()
2655 2659 if v.startswith('S:')]
2656 2660 vars.sort()
2657 2661 if vars:
2658 2662 size = max(map(len,vars))
2659 2663 else:
2660 2664 size = 0
2661 2665
2662 2666 print 'Stored variables and their in-memory values:'
2663 2667 fmt = '%-'+str(size)+'s -> %s'
2664 2668 get = self.shell.user_ns.get
2665 2669 for var in vars:
2666 2670 # print 30 first characters from every var
2667 2671 print fmt % (var,repr(get(var,'<unavailable>'))[:50])
2668 2672
2669 2673 # default action - store the variable
2670 2674 else:
2671 2675 pickled = pickle.dumps(self.shell.user_ns[args[0] ])
2672 2676 self.shell.persist[ 'S:' + args[0] ] = pickled
2673 2677 print "Stored '%s' (%d bytes)" % (args[0], len(pickled))
2674 2678
2675 2679 def magic_bookmark(self, parameter_s=''):
2676 2680 """Manage IPython's bookmark system.
2677 2681
2678 2682 %bookmark <name> - set bookmark to current dir
2679 2683 %bookmark <name> <dir> - set bookmark to <dir>
2680 2684 %bookmark -l - list all bookmarks
2681 2685 %bookmark -d <name> - remove bookmark
2682 2686 %bookmark -r - remove all bookmarks
2683 2687
2684 2688 You can later on access a bookmarked folder with:
2685 2689 %cd -b <name>
2686 2690 or simply '%cd <name>' if there is no directory called <name> AND
2687 2691 there is such a bookmark defined.
2688 2692
2689 2693 Your bookmarks persist through IPython sessions, but they are
2690 2694 associated with each profile."""
2691 2695
2692 2696 opts,args = self.parse_options(parameter_s,'drl',mode='list')
2693 2697 if len(args) > 2:
2694 2698 error('You can only give at most two arguments')
2695 2699 return
2696 2700
2697 2701 bkms = self.shell.persist.get('bookmarks',{})
2698 2702
2699 2703 if opts.has_key('d'):
2700 2704 try:
2701 2705 todel = args[0]
2702 2706 except IndexError:
2703 2707 error('You must provide a bookmark to delete')
2704 2708 else:
2705 2709 try:
2706 2710 del bkms[todel]
2707 2711 except:
2708 2712 error("Can't delete bookmark '%s'" % todel)
2709 2713 elif opts.has_key('r'):
2710 2714 bkms = {}
2711 2715 elif opts.has_key('l'):
2712 2716 bks = bkms.keys()
2713 2717 bks.sort()
2714 2718 if bks:
2715 2719 size = max(map(len,bks))
2716 2720 else:
2717 2721 size = 0
2718 2722 fmt = '%-'+str(size)+'s -> %s'
2719 2723 print 'Current bookmarks:'
2720 2724 for bk in bks:
2721 2725 print fmt % (bk,bkms[bk])
2722 2726 else:
2723 2727 if not args:
2724 2728 error("You must specify the bookmark name")
2725 2729 elif len(args)==1:
2726 2730 bkms[args[0]] = os.getcwd()
2727 2731 elif len(args)==2:
2728 2732 bkms[args[0]] = args[1]
2729 2733 self.shell.persist['bookmarks'] = bkms
2730 2734
2731 2735 def magic_pycat(self, parameter_s=''):
2732 2736 """Show a syntax-highlighted file through a pager.
2733 2737
2734 2738 This magic is similar to the cat utility, but it will assume the file
2735 2739 to be Python source and will show it with syntax highlighting. """
2736 2740
2737 2741 filename = get_py_filename(parameter_s)
2738 2742 page(self.shell.pycolorize(file_read(filename)),
2739 2743 screen_lines=self.shell.rc.screen_length)
2740 2744
2741 2745 # end Magic
@@ -1,76 +1,77 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Release data for the IPython project.
3 3
4 $Id: Release.py 1002 2006-01-11 22:18:29Z fperez $"""
4 $Id: Release.py 1014 2006-01-13 19:16:41Z vivainio $"""
5 5
6 6 #*****************************************************************************
7 7 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
8 8 #
9 9 # Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
10 10 # <n8gray@caltech.edu>
11 11 #
12 12 # Distributed under the terms of the BSD License. The full license is in
13 13 # the file COPYING, distributed as part of this software.
14 14 #*****************************************************************************
15 15
16 16 # Name of the package for release purposes. This is the name which labels
17 17 # the tarballs and RPMs made by distutils, so it's best to lowercase it.
18 18 name = 'ipython'
19 19
20 20 # For versions with substrings (like 0.6.16.svn), use an extra . to separate
21 21 # the new substring. We have to avoid using either dashes or underscores,
22 22 # because bdist_rpm does not accept dashes (an RPM) convention, and
23 23 # bdist_deb does not accept underscores (a Debian convention).
24 24
25 25 version = '0.7.1.svn'
26 26
27 revision = '$Revision: 1002 $'
27 revision = '$Revision: 1014 $'
28 28
29 29 description = "An enhanced interactive Python shell."
30 30
31 31 long_description = \
32 32 """
33 33 IPython provides a replacement for the interactive Python interpreter with
34 34 extra functionality.
35 35
36 36 Main features:
37 37
38 38 * Comprehensive object introspection.
39 39
40 40 * Input history, persistent across sessions.
41 41
42 42 * Caching of output results during a session with automatically generated
43 43 references.
44 44
45 45 * Readline based name completion.
46 46
47 47 * Extensible system of 'magic' commands for controlling the environment and
48 48 performing many tasks related either to IPython or the operating system.
49 49
50 50 * Configuration system with easy switching between different setups (simpler
51 51 than changing $PYTHONSTARTUP environment variables every time).
52 52
53 53 * Session logging and reloading.
54 54
55 55 * Extensible syntax processing for special purpose situations.
56 56
57 57 * Access to the system shell with user-extensible alias system.
58 58
59 59 * Easily embeddable in other Python programs.
60 60
61 61 * Integrated access to the pdb debugger and the Python profiler. """
62 62
63 63 license = 'BSD'
64 64
65 65 authors = {'Fernando' : ('Fernando Perez','fperez@colorado.edu'),
66 66 'Janko' : ('Janko Hauser','jhauser@zscout.de'),
67 'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu')
67 'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu'),
68 'Ville' : ('Ville Vainio','vivainio@gmail.com')
68 69 }
69 70
70 71 url = 'http://ipython.scipy.org'
71 72
72 73 download_url = 'http://ipython.scipy.org/dist'
73 74
74 75 platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
75 76
76 77 keywords = ['Interactive','Interpreter','Shell']
@@ -1,64 +1,65 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 IPython -- An enhanced Interactive Python
4 4
5 5 One of Python's nicest features is its interactive interpreter. This allows
6 6 very fast testing of ideas without the overhead of creating test files as is
7 7 typical in most programming languages. However, the interpreter supplied with
8 8 the standard Python distribution is fairly primitive (and IDLE isn't really
9 9 much better).
10 10
11 11 IPython tries to:
12 12
13 13 i - provide an efficient environment for interactive work in Python
14 14 programming. It tries to address what we see as shortcomings of the standard
15 15 Python prompt, and adds many features to make interactive work much more
16 16 efficient.
17 17
18 18 ii - offer a flexible framework so that it can be used as the base
19 19 environment for other projects and problems where Python can be the
20 20 underlying language. Specifically scientific environments like Mathematica,
21 21 IDL and Mathcad inspired its design, but similar ideas can be useful in many
22 22 fields. Python is a fabulous language for implementing this kind of system
23 23 (due to its dynamic and introspective features), and with suitable libraries
24 24 entire systems could be built leveraging Python's power.
25 25
26 26 iii - serve as an embeddable, ready to go interpreter for your own programs.
27 27
28 28 IPython requires Python 2.2 or newer.
29 29
30 $Id: __init__.py 1005 2006-01-12 08:39:26Z fperez $"""
30 $Id: __init__.py 1014 2006-01-13 19:16:41Z vivainio $"""
31 31
32 32 #*****************************************************************************
33 33 # Copyright (C) 2001-2004 Fernando Perez. <fperez@colorado.edu>
34 34 #
35 35 # Distributed under the terms of the BSD License. The full license is in
36 36 # the file COPYING, distributed as part of this software.
37 37 #*****************************************************************************
38 38
39 39 # Enforce proper version requirements
40 40 import sys
41 41 if sys.version[0:3] < '2.3':
42 42 raise ImportError, 'Python Version 2.3 or above is required.'
43 43
44 44 # Define what gets imported with a 'from IPython import *'
45 45 __all__ = ['deep_reload','genutils','ipstruct','ultraTB','DPyGetOpt',
46 'Itpl','hooks','ConfigLoader','OutputTrap','Release','Shell']
46 'Itpl','hooks','ConfigLoader','OutputTrap','Release','Shell',
47 'platutils','platutils_win32','platutils_posix','platutils_dummy']
47 48
48 49 # Load __all__ in IPython namespace so that a simple 'import IPython' gives
49 50 # access to them via IPython.<name>
50 51 glob,loc = globals(),locals()
51 52 for name in __all__:
52 53 __import__(name,glob,loc,[])
53 54
54 55 # Release data
55 56 from IPython import Release # do it explicitly so pydoc can see it - pydoc bug
56 57 __author__ = '%s <%s>\n%s <%s>\n%s <%s>' % \
57 58 ( Release.authors['Fernando'] + Release.authors['Janko'] + \
58 59 Release.authors['Nathan'] )
59 60 __license__ = Release.license
60 61 __version__ = Release.version
61 62 __revision__ = Release.revision
62 63
63 64 # Namespace cleanup
64 65 del name,glob,loc
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now