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