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