##// END OF EJS Templates
make Completer.greedy configurable
MinRK -
Show More
@@ -1,874 +1,903 b''
1 1 """Word completion for IPython.
2 2
3 3 This module is a fork of the rlcompleter module in the Python standard
4 4 library. The original enhancements made to rlcompleter have been sent
5 5 upstream and were accepted as of Python 2.3, but we need a lot more
6 6 functionality specific to IPython, so this module will continue to live as an
7 7 IPython-specific utility.
8 8
9 9 Original rlcompleter documentation:
10 10
11 11 This requires the latest extension to the readline module (the
12 12 completes keywords, built-ins and globals in __main__; when completing
13 13 NAME.NAME..., it evaluates (!) the expression up to the last dot and
14 14 completes its attributes.
15 15
16 16 It's very cool to do "import string" type "string.", hit the
17 17 completion key (twice), and see the list of names defined by the
18 18 string module!
19 19
20 20 Tip: to use the tab key as the completion key, call
21 21
22 22 readline.parse_and_bind("tab: complete")
23 23
24 24 Notes:
25 25
26 26 - Exceptions raised by the completer function are *ignored* (and
27 27 generally cause the completion to fail). This is a feature -- since
28 28 readline sets the tty device in raw (or cbreak) mode, printing a
29 29 traceback wouldn't work well without some complicated hoopla to save,
30 30 reset and restore the tty state.
31 31
32 32 - The evaluation of the NAME.NAME... form may cause arbitrary
33 33 application defined code to be executed if an object with a
34 34 __getattr__ hook is found. Since it is the responsibility of the
35 35 application (or the user) to enable this feature, I consider this an
36 36 acceptable risk. More complicated expressions (e.g. function calls or
37 37 indexing operations) are *not* evaluated.
38 38
39 39 - GNU readline is also used by the built-in functions input() and
40 40 raw_input(), and thus these also benefit/suffer from the completer
41 41 features. Clearly an interactive application can benefit by
42 42 specifying its own completer function and using raw_input() for all
43 43 its input.
44 44
45 45 - When the original stdin is not a tty device, GNU readline is never
46 46 used, and this module (and the readline module) are silently inactive.
47 47 """
48 48
49 49 #*****************************************************************************
50 50 #
51 51 # Since this file is essentially a minimally modified copy of the rlcompleter
52 52 # module which is part of the standard Python distribution, I assume that the
53 53 # proper procedure is to maintain its copyright as belonging to the Python
54 54 # Software Foundation (in addition to my own, for all new code).
55 55 #
56 56 # Copyright (C) 2008-2010 IPython Development Team
57 57 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
58 58 # Copyright (C) 2001 Python Software Foundation, www.python.org
59 59 #
60 60 # Distributed under the terms of the BSD License. The full license is in
61 61 # the file COPYING, distributed as part of this software.
62 62 #
63 63 #*****************************************************************************
64 64 from __future__ import print_function
65 65
66 66 #-----------------------------------------------------------------------------
67 67 # Imports
68 68 #-----------------------------------------------------------------------------
69 69
70 70 import __builtin__
71 71 import __main__
72 72 import glob
73 73 import inspect
74 74 import itertools
75 75 import keyword
76 76 import os
77 77 import re
78 78 import shlex
79 79 import sys
80 80
81 from IPython.config.configurable import Configurable
81 82 from IPython.core.error import TryNext
82 83 from IPython.core.prefilter import ESC_MAGIC
83 84 from IPython.utils import generics
84 85 from IPython.utils import io
85 86 from IPython.utils.dir2 import dir2
86 87 from IPython.utils.process import arg_split
88 from IPython.utils.traitlets import CBool
87 89
88 90 #-----------------------------------------------------------------------------
89 91 # Globals
90 92 #-----------------------------------------------------------------------------
91 93
92 94 # Public API
93 95 __all__ = ['Completer','IPCompleter']
94 96
95 97 if sys.platform == 'win32':
96 98 PROTECTABLES = ' '
97 99 else:
98 100 PROTECTABLES = ' ()[]{}?=\\|;:\'#*"^&'
99 101
100 102 #-----------------------------------------------------------------------------
101 103 # Main functions and classes
102 104 #-----------------------------------------------------------------------------
103 105
104 106 def has_open_quotes(s):
105 107 """Return whether a string has open quotes.
106 108
107 109 This simply counts whether the number of quote characters of either type in
108 110 the string is odd.
109 111
110 112 Returns
111 113 -------
112 114 If there is an open quote, the quote character is returned. Else, return
113 115 False.
114 116 """
115 117 # We check " first, then ', so complex cases with nested quotes will get
116 118 # the " to take precedence.
117 119 if s.count('"') % 2:
118 120 return '"'
119 121 elif s.count("'") % 2:
120 122 return "'"
121 123 else:
122 124 return False
123 125
124 126
125 127 def protect_filename(s):
126 128 """Escape a string to protect certain characters."""
127 129
128 130 return "".join([(ch in PROTECTABLES and '\\' + ch or ch)
129 131 for ch in s])
130 132
131 133
132 134 def mark_dirs(matches):
133 135 """Mark directories in input list by appending '/' to their names."""
134 136 out = []
135 137 isdir = os.path.isdir
136 138 for x in matches:
137 139 if isdir(x):
138 140 out.append(x+'/')
139 141 else:
140 142 out.append(x)
141 143 return out
142 144
143 145
144 146 def expand_user(path):
145 147 """Expand '~'-style usernames in strings.
146 148
147 149 This is similar to :func:`os.path.expanduser`, but it computes and returns
148 150 extra information that will be useful if the input was being used in
149 151 computing completions, and you wish to return the completions with the
150 152 original '~' instead of its expanded value.
151 153
152 154 Parameters
153 155 ----------
154 156 path : str
155 157 String to be expanded. If no ~ is present, the output is the same as the
156 158 input.
157 159
158 160 Returns
159 161 -------
160 162 newpath : str
161 163 Result of ~ expansion in the input path.
162 164 tilde_expand : bool
163 165 Whether any expansion was performed or not.
164 166 tilde_val : str
165 167 The value that ~ was replaced with.
166 168 """
167 169 # Default values
168 170 tilde_expand = False
169 171 tilde_val = ''
170 172 newpath = path
171 173
172 174 if path.startswith('~'):
173 175 tilde_expand = True
174 176 rest = path[1:]
175 177 newpath = os.path.expanduser(path)
176 178 tilde_val = newpath.replace(rest, '')
177 179
178 180 return newpath, tilde_expand, tilde_val
179 181
180 182
181 183 def compress_user(path, tilde_expand, tilde_val):
182 184 """Does the opposite of expand_user, with its outputs.
183 185 """
184 186 if tilde_expand:
185 187 return path.replace(tilde_val, '~')
186 188 else:
187 189 return path
188 190
189 191
190 192 def single_dir_expand(matches):
191 193 "Recursively expand match lists containing a single dir."
192 194
193 195 if len(matches) == 1 and os.path.isdir(matches[0]):
194 196 # Takes care of links to directories also. Use '/'
195 197 # explicitly, even under Windows, so that name completions
196 198 # don't end up escaped.
197 199 d = matches[0]
198 200 if d[-1] in ['/','\\']:
199 201 d = d[:-1]
200 202
201 203 subdirs = os.listdir(d)
202 204 if subdirs:
203 205 matches = [ (d + '/' + p) for p in subdirs]
204 206 return single_dir_expand(matches)
205 207 else:
206 208 return matches
207 209 else:
208 210 return matches
209 211
210 212
211 213 class Bunch(object): pass
212 214
215 DELIMS = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
216 GREEDY_DELIMS = ' \r\n'
213 217
214 218 class CompletionSplitter(object):
215 219 """An object to split an input line in a manner similar to readline.
216 220
217 221 By having our own implementation, we can expose readline-like completion in
218 222 a uniform manner to all frontends. This object only needs to be given the
219 223 line of text to be split and the cursor position on said line, and it
220 224 returns the 'word' to be completed on at the cursor after splitting the
221 225 entire line.
222 226
223 227 What characters are used as splitting delimiters can be controlled by
224 228 setting the `delims` attribute (this is a property that internally
225 229 automatically builds the necessary """
226 230
227 231 # Private interface
228 232
229 233 # A string of delimiter characters. The default value makes sense for
230 234 # IPython's most typical usage patterns.
231 #_delims = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
232 _delims = ' \n\t'
235 _delims = DELIMS
233 236
234 237 # The expression (a normal string) to be compiled into a regular expression
235 238 # for actual splitting. We store it as an attribute mostly for ease of
236 239 # debugging, since this type of code can be so tricky to debug.
237 240 _delim_expr = None
238 241
239 242 # The regular expression that does the actual splitting
240 243 _delim_re = None
241 244
242 245 def __init__(self, delims=None):
243 246 delims = CompletionSplitter._delims if delims is None else delims
244 247 self.set_delims(delims)
245 248
246 249 def set_delims(self, delims):
247 250 """Set the delimiters for line splitting."""
248 251 expr = '[' + ''.join('\\'+ c for c in delims) + ']'
249 252 self._delim_re = re.compile(expr)
250 253 self._delims = delims
251 254 self._delim_expr = expr
252 255
253 256 def get_delims(self):
254 257 """Return the string of delimiter characters."""
255 258 return self._delims
256 259
257 260 def split_line(self, line, cursor_pos=None):
258 261 """Split a line of text with a cursor at the given position.
259 262 """
260 263 l = line if cursor_pos is None else line[:cursor_pos]
261 264 return self._delim_re.split(l)[-1]
262 265
263 266
264 class Completer(object):
265 def __init__(self, namespace=None, global_namespace=None):
267 class Completer(Configurable):
268
269 greedy = CBool(False, config=True,
270 help="""Activate greedy completion
271
272 This will enable completion on elements of lists, results of function calls, etc.,
273 but can be unsafe because the code is actually evaluated on TAB.
274 """
275 )
276
277 def __init__(self, namespace=None, global_namespace=None, config=None):
266 278 """Create a new completer for the command line.
267 279
268 Completer([namespace,global_namespace]) -> completer instance.
280 Completer(namespace=ns,global_namespace=ns2) -> completer instance.
269 281
270 282 If unspecified, the default namespace where completions are performed
271 283 is __main__ (technically, __main__.__dict__). Namespaces should be
272 284 given as dictionaries.
273 285
274 286 An optional second namespace can be given. This allows the completer
275 287 to handle cases where both the local and global scopes need to be
276 288 distinguished.
277 289
278 290 Completer instances should be used as the completion mechanism of
279 291 readline via the set_completer() call:
280 292
281 293 readline.set_completer(Completer(my_namespace).complete)
282 294 """
283 295
284 296 # Don't bind to namespace quite yet, but flag whether the user wants a
285 297 # specific namespace or to use __main__.__dict__. This will allow us
286 298 # to bind to __main__.__dict__ at completion time, not now.
287 299 if namespace is None:
288 300 self.use_main_ns = 1
289 301 else:
290 302 self.use_main_ns = 0
291 303 self.namespace = namespace
292 304
293 305 # The global namespace, if given, can be bound directly
294 306 if global_namespace is None:
295 307 self.global_namespace = {}
296 308 else:
297 309 self.global_namespace = global_namespace
310
311 super(Completer, self).__init__(config=config)
298 312
299 313 def complete(self, text, state):
300 314 """Return the next possible completion for 'text'.
301 315
302 316 This is called successively with state == 0, 1, 2, ... until it
303 317 returns None. The completion should begin with 'text'.
304 318
305 319 """
306 320 if self.use_main_ns:
307 321 self.namespace = __main__.__dict__
308 322
309 323 if state == 0:
310 324 if "." in text:
311 325 self.matches = self.attr_matches(text)
312 326 else:
313 327 self.matches = self.global_matches(text)
314 328 try:
315 329 return self.matches[state]
316 330 except IndexError:
317 331 return None
318 332
319 333 def global_matches(self, text):
320 334 """Compute matches when text is a simple name.
321 335
322 336 Return a list of all keywords, built-in functions and names currently
323 337 defined in self.namespace or self.global_namespace that match.
324 338
325 339 """
326 340 #print 'Completer->global_matches, txt=%r' % text # dbg
327 341 matches = []
328 342 match_append = matches.append
329 343 n = len(text)
330 344 for lst in [keyword.kwlist,
331 345 __builtin__.__dict__.keys(),
332 346 self.namespace.keys(),
333 347 self.global_namespace.keys()]:
334 348 for word in lst:
335 349 if word[:n] == text and word != "__builtins__":
336 350 match_append(word)
337 351 return matches
338 352
339 353 def attr_matches(self, text):
340 354 """Compute matches when text contains a dot.
341 355
342 356 Assuming the text is of the form NAME.NAME....[NAME], and is
343 357 evaluatable in self.namespace or self.global_namespace, it will be
344 358 evaluated and its attributes (as revealed by dir()) are used as
345 359 possible completions. (For class instances, class members are are
346 360 also considered.)
347 361
348 362 WARNING: this can still invoke arbitrary C code, if an object
349 363 with a __getattr__ hook is evaluated.
350 364
351 365 """
352 366
353 367 #io.rprint('Completer->attr_matches, txt=%r' % text) # dbg
354 368 # Another option, seems to work great. Catches things like ''.<tab>
355 369 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
356 370
357 371 if m:
358 372 expr, attr = m.group(1, 3)
359 else:
373 elif self.greedy:
360 374 m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
361 375 if not m2:
362 376 return []
363 377 expr, attr = m2.group(1,2)
378 else:
379 return []
364 380
365 381 try:
366 382 obj = eval(expr, self.namespace)
367 383 except:
368 384 try:
369 385 obj = eval(expr, self.global_namespace)
370 386 except:
371 387 return []
372 388
373 389 words = dir2(obj)
374 390
375 391 try:
376 392 words = generics.complete_object(obj, words)
377 393 except TryNext:
378 394 pass
379 395 # Build match list to return
380 396 n = len(attr)
381 397 res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
382 398 return res
383 399
384 400
385 401 class IPCompleter(Completer):
386 402 """Extension of the completer class with IPython-specific features"""
387 403
388 def __init__(self, shell, namespace=None, global_namespace=None,
389 omit__names=True, alias_table=None, use_readline=True):
404 def _greedy_changed(self, name, old, new):
405 """update the splitter and readline delims when greedy is changed"""
406 if new:
407 self.splitter.set_delims(GREEDY_DELIMS)
408 else:
409 self.splitter.set_delims(DELIMS)
410
411 if self.readline:
412 self.readline.set_completer_delims(self.splitter.get_delims())
413
414 def __init__(self, shell=None, namespace=None, global_namespace=None,
415 omit__names=True, alias_table=None, use_readline=True,
416 config=None):
390 417 """IPCompleter() -> completer
391 418
392 419 Return a completer object suitable for use by the readline library
393 420 via readline.set_completer().
394 421
395 422 Inputs:
396 423
397 424 - shell: a pointer to the ipython shell itself. This is needed
398 425 because this completer knows about magic functions, and those can
399 426 only be accessed via the ipython instance.
400 427
401 428 - namespace: an optional dict where completions are performed.
402 429
403 430 - global_namespace: secondary optional dict for completions, to
404 431 handle cases (such as IPython embedded inside functions) where
405 432 both Python scopes are visible.
406 433
407 434 - The optional omit__names parameter sets the completer to omit the
408 435 'magic' names (__magicname__) for python objects unless the text
409 436 to be completed explicitly starts with one or more underscores.
410 437
411 438 - If alias_table is supplied, it should be a dictionary of aliases
412 439 to complete.
413 440
414 441 use_readline : bool, optional
415 442 If true, use the readline library. This completer can still function
416 443 without readline, though in that case callers must provide some extra
417 444 information on each call about the current line."""
418 445
419 Completer.__init__(self, namespace, global_namespace)
420
421 446 self.magic_escape = ESC_MAGIC
422 447 self.splitter = CompletionSplitter()
423 448
424 449 # Readline configuration, only used by the rlcompleter method.
425 450 if use_readline:
426 451 # We store the right version of readline so that later code
427 452 import IPython.utils.rlineimpl as readline
428 453 self.readline = readline
429 454 else:
430 455 self.readline = None
431 456
457 # _greedy_changed() depends on splitter and readline being defined:
458 Completer.__init__(self, namespace=namespace, global_namespace=global_namespace,
459 config=config)
460
432 461 # List where completion matches will be stored
433 462 self.matches = []
434 463 self.omit__names = omit__names
435 464 self.merge_completions = shell.readline_merge_completions
436 465 self.shell = shell.shell
437 466 if alias_table is None:
438 467 alias_table = {}
439 468 self.alias_table = alias_table
440 469 # Regexp to split filenames with spaces in them
441 470 self.space_name_re = re.compile(r'([^\\] )')
442 471 # Hold a local ref. to glob.glob for speed
443 472 self.glob = glob.glob
444 473
445 474 # Determine if we are running on 'dumb' terminals, like (X)Emacs
446 475 # buffers, to avoid completion problems.
447 476 term = os.environ.get('TERM','xterm')
448 477 self.dumb_terminal = term in ['dumb','emacs']
449 478
450 479 # Special handling of backslashes needed in win32 platforms
451 480 if sys.platform == "win32":
452 481 self.clean_glob = self._clean_glob_win32
453 482 else:
454 483 self.clean_glob = self._clean_glob
455 484
456 485 # All active matcher routines for completion
457 486 self.matchers = [self.python_matches,
458 487 self.file_matches,
459 488 self.magic_matches,
460 489 self.alias_matches,
461 490 self.python_func_kw_matches,
462 491 ]
463 492
464 493 def all_completions(self, text):
465 494 """
466 495 Wrapper around the complete method for the benefit of emacs
467 496 and pydb.
468 497 """
469 498 return self.complete(text)[1]
470 499
471 500 def _clean_glob(self,text):
472 501 return self.glob("%s*" % text)
473 502
474 503 def _clean_glob_win32(self,text):
475 504 return [f.replace("\\","/")
476 505 for f in self.glob("%s*" % text)]
477 506
478 507 def file_matches(self, text):
479 508 """Match filenames, expanding ~USER type strings.
480 509
481 510 Most of the seemingly convoluted logic in this completer is an
482 511 attempt to handle filenames with spaces in them. And yet it's not
483 512 quite perfect, because Python's readline doesn't expose all of the
484 513 GNU readline details needed for this to be done correctly.
485 514
486 515 For a filename with a space in it, the printed completions will be
487 516 only the parts after what's already been typed (instead of the
488 517 full completions, as is normally done). I don't think with the
489 518 current (as of Python 2.3) Python readline it's possible to do
490 519 better."""
491 520
492 521 #io.rprint('Completer->file_matches: <%r>' % text) # dbg
493 522
494 523 # chars that require escaping with backslash - i.e. chars
495 524 # that readline treats incorrectly as delimiters, but we
496 525 # don't want to treat as delimiters in filename matching
497 526 # when escaped with backslash
498 527 if text.startswith('!'):
499 528 text = text[1:]
500 529 text_prefix = '!'
501 530 else:
502 531 text_prefix = ''
503 532
504 533 text_until_cursor = self.text_until_cursor
505 534 # track strings with open quotes
506 535 open_quotes = has_open_quotes(text_until_cursor)
507 536
508 537 if '(' in text_until_cursor or '[' in text_until_cursor:
509 538 lsplit = text
510 539 else:
511 540 try:
512 541 # arg_split ~ shlex.split, but with unicode bugs fixed by us
513 542 lsplit = arg_split(text_until_cursor)[-1]
514 543 except ValueError:
515 544 # typically an unmatched ", or backslash without escaped char.
516 545 if open_quotes:
517 546 lsplit = text_until_cursor.split(open_quotes)[-1]
518 547 else:
519 548 return []
520 549 except IndexError:
521 550 # tab pressed on empty line
522 551 lsplit = ""
523 552
524 553 if not open_quotes and lsplit != protect_filename(lsplit):
525 554 # if protectables are found, do matching on the whole escaped name
526 555 has_protectables = True
527 556 text0,text = text,lsplit
528 557 else:
529 558 has_protectables = False
530 559 text = os.path.expanduser(text)
531 560
532 561 if text == "":
533 562 return [text_prefix + protect_filename(f) for f in self.glob("*")]
534 563
535 564 # Compute the matches from the filesystem
536 565 m0 = self.clean_glob(text.replace('\\',''))
537 566
538 567 if has_protectables:
539 568 # If we had protectables, we need to revert our changes to the
540 569 # beginning of filename so that we don't double-write the part
541 570 # of the filename we have so far
542 571 len_lsplit = len(lsplit)
543 572 matches = [text_prefix + text0 +
544 573 protect_filename(f[len_lsplit:]) for f in m0]
545 574 else:
546 575 if open_quotes:
547 576 # if we have a string with an open quote, we don't need to
548 577 # protect the names at all (and we _shouldn't_, as it
549 578 # would cause bugs when the filesystem call is made).
550 579 matches = m0
551 580 else:
552 581 matches = [text_prefix +
553 582 protect_filename(f) for f in m0]
554 583
555 584 #io.rprint('mm', matches) # dbg
556 585 return mark_dirs(matches)
557 586
558 587 def magic_matches(self, text):
559 588 """Match magics"""
560 589 #print 'Completer->magic_matches:',text,'lb',self.text_until_cursor # dbg
561 590 # Get all shell magics now rather than statically, so magics loaded at
562 591 # runtime show up too
563 592 magics = self.shell.lsmagic()
564 593 pre = self.magic_escape
565 594 baretext = text.lstrip(pre)
566 595 return [ pre+m for m in magics if m.startswith(baretext)]
567 596
568 597 def alias_matches(self, text):
569 598 """Match internal system aliases"""
570 599 #print 'Completer->alias_matches:',text,'lb',self.text_until_cursor # dbg
571 600
572 601 # if we are not in the first 'item', alias matching
573 602 # doesn't make sense - unless we are starting with 'sudo' command.
574 603 main_text = self.text_until_cursor.lstrip()
575 604 if ' ' in main_text and not main_text.startswith('sudo'):
576 605 return []
577 606 text = os.path.expanduser(text)
578 607 aliases = self.alias_table.keys()
579 608 if text == '':
580 609 return aliases
581 610 else:
582 611 return [a for a in aliases if a.startswith(text)]
583 612
584 613 def python_matches(self,text):
585 614 """Match attributes or global python names"""
586 615
587 616 #io.rprint('Completer->python_matches, txt=%r' % text) # dbg
588 617 if "." in text:
589 618 try:
590 619 matches = self.attr_matches(text)
591 620 if text.endswith('.') and self.omit__names:
592 621 if self.omit__names == 1:
593 622 # true if txt is _not_ a __ name, false otherwise:
594 623 no__name = (lambda txt:
595 624 re.match(r'.*\.__.*?__',txt) is None)
596 625 else:
597 626 # true if txt is _not_ a _ name, false otherwise:
598 627 no__name = (lambda txt:
599 628 re.match(r'.*\._.*?',txt) is None)
600 629 matches = filter(no__name, matches)
601 630 except NameError:
602 631 # catches <undefined attributes>.<tab>
603 632 matches = []
604 633 else:
605 634 matches = self.global_matches(text)
606 635
607 636 return matches
608 637
609 638 def _default_arguments(self, obj):
610 639 """Return the list of default arguments of obj if it is callable,
611 640 or empty list otherwise."""
612 641
613 642 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
614 643 # for classes, check for __init__,__new__
615 644 if inspect.isclass(obj):
616 645 obj = (getattr(obj,'__init__',None) or
617 646 getattr(obj,'__new__',None))
618 647 # for all others, check if they are __call__able
619 648 elif hasattr(obj, '__call__'):
620 649 obj = obj.__call__
621 650 # XXX: is there a way to handle the builtins ?
622 651 try:
623 652 args,_,_1,defaults = inspect.getargspec(obj)
624 653 if defaults:
625 654 return args[-len(defaults):]
626 655 except TypeError: pass
627 656 return []
628 657
629 658 def python_func_kw_matches(self,text):
630 659 """Match named parameters (kwargs) of the last open function"""
631 660
632 661 if "." in text: # a parameter cannot be dotted
633 662 return []
634 663 try: regexp = self.__funcParamsRegex
635 664 except AttributeError:
636 665 regexp = self.__funcParamsRegex = re.compile(r'''
637 666 '.*?' | # single quoted strings or
638 667 ".*?" | # double quoted strings or
639 668 \w+ | # identifier
640 669 \S # other characters
641 670 ''', re.VERBOSE | re.DOTALL)
642 671 # 1. find the nearest identifier that comes before an unclosed
643 672 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
644 673 tokens = regexp.findall(self.line_buffer)
645 674 tokens.reverse()
646 675 iterTokens = iter(tokens); openPar = 0
647 676 for token in iterTokens:
648 677 if token == ')':
649 678 openPar -= 1
650 679 elif token == '(':
651 680 openPar += 1
652 681 if openPar > 0:
653 682 # found the last unclosed parenthesis
654 683 break
655 684 else:
656 685 return []
657 686 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
658 687 ids = []
659 688 isId = re.compile(r'\w+$').match
660 689 while True:
661 690 try:
662 691 ids.append(iterTokens.next())
663 692 if not isId(ids[-1]):
664 693 ids.pop(); break
665 694 if not iterTokens.next() == '.':
666 695 break
667 696 except StopIteration:
668 697 break
669 698 # lookup the candidate callable matches either using global_matches
670 699 # or attr_matches for dotted names
671 700 if len(ids) == 1:
672 701 callableMatches = self.global_matches(ids[0])
673 702 else:
674 703 callableMatches = self.attr_matches('.'.join(ids[::-1]))
675 704 argMatches = []
676 705 for callableMatch in callableMatches:
677 706 try:
678 707 namedArgs = self._default_arguments(eval(callableMatch,
679 708 self.namespace))
680 709 except:
681 710 continue
682 711 for namedArg in namedArgs:
683 712 if namedArg.startswith(text):
684 713 argMatches.append("%s=" %namedArg)
685 714 return argMatches
686 715
687 716 def dispatch_custom_completer(self, text):
688 717 #io.rprint("Custom! '%s' %s" % (text, self.custom_completers)) # dbg
689 718 line = self.line_buffer
690 719 if not line.strip():
691 720 return None
692 721
693 722 # Create a little structure to pass all the relevant information about
694 723 # the current completion to any custom completer.
695 724 event = Bunch()
696 725 event.line = line
697 726 event.symbol = text
698 727 cmd = line.split(None,1)[0]
699 728 event.command = cmd
700 729 event.text_until_cursor = self.text_until_cursor
701 730
702 731 #print "\ncustom:{%s]\n" % event # dbg
703 732
704 733 # for foo etc, try also to find completer for %foo
705 734 if not cmd.startswith(self.magic_escape):
706 735 try_magic = self.custom_completers.s_matches(
707 736 self.magic_escape + cmd)
708 737 else:
709 738 try_magic = []
710 739
711 740 for c in itertools.chain(self.custom_completers.s_matches(cmd),
712 741 try_magic,
713 742 self.custom_completers.flat_matches(self.text_until_cursor)):
714 743 #print "try",c # dbg
715 744 try:
716 745 res = c(event)
717 746 if res:
718 747 # first, try case sensitive match
719 748 withcase = [r for r in res if r.startswith(text)]
720 749 if withcase:
721 750 return withcase
722 751 # if none, then case insensitive ones are ok too
723 752 text_low = text.lower()
724 753 return [r for r in res if r.lower().startswith(text_low)]
725 754 except TryNext:
726 755 pass
727 756
728 757 return None
729 758
730 759 def complete(self, text=None, line_buffer=None, cursor_pos=None):
731 760 """Find completions for the given text and line context.
732 761
733 762 This is called successively with state == 0, 1, 2, ... until it
734 763 returns None. The completion should begin with 'text'.
735 764
736 765 Note that both the text and the line_buffer are optional, but at least
737 766 one of them must be given.
738 767
739 768 Parameters
740 769 ----------
741 770 text : string, optional
742 771 Text to perform the completion on. If not given, the line buffer
743 772 is split using the instance's CompletionSplitter object.
744 773
745 774 line_buffer : string, optional
746 775 If not given, the completer attempts to obtain the current line
747 776 buffer via readline. This keyword allows clients which are
748 777 requesting for text completions in non-readline contexts to inform
749 778 the completer of the entire text.
750 779
751 780 cursor_pos : int, optional
752 781 Index of the cursor in the full line buffer. Should be provided by
753 782 remote frontends where kernel has no access to frontend state.
754 783
755 784 Returns
756 785 -------
757 786 text : str
758 787 Text that was actually used in the completion.
759 788
760 789 matches : list
761 790 A list of completion matches.
762 791 """
763 792 #io.rprint('\nCOMP1 %r %r %r' % (text, line_buffer, cursor_pos)) # dbg
764 793
765 794 # if the cursor position isn't given, the only sane assumption we can
766 795 # make is that it's at the end of the line (the common case)
767 796 if cursor_pos is None:
768 797 cursor_pos = len(line_buffer) if text is None else len(text)
769 798
770 799 # if text is either None or an empty string, rely on the line buffer
771 800 if not text:
772 801 text = self.splitter.split_line(line_buffer, cursor_pos)
773 802
774 803 # If no line buffer is given, assume the input text is all there was
775 804 if line_buffer is None:
776 805 line_buffer = text
777 806
778 807 self.line_buffer = line_buffer
779 808 self.text_until_cursor = self.line_buffer[:cursor_pos]
780 809 #io.rprint('\nCOMP2 %r %r %r' % (text, line_buffer, cursor_pos)) # dbg
781 810
782 811 # Start with a clean slate of completions
783 812 self.matches[:] = []
784 813 custom_res = self.dispatch_custom_completer(text)
785 814 if custom_res is not None:
786 815 # did custom completers produce something?
787 816 self.matches = custom_res
788 817 else:
789 818 # Extend the list of completions with the results of each
790 819 # matcher, so we return results to the user from all
791 820 # namespaces.
792 821 if self.merge_completions:
793 822 self.matches = []
794 823 for matcher in self.matchers:
795 824 try:
796 825 self.matches.extend(matcher(text))
797 826 except:
798 827 # Show the ugly traceback if the matcher causes an
799 828 # exception, but do NOT crash the kernel!
800 829 sys.excepthook(*sys.exc_info())
801 830 else:
802 831 for matcher in self.matchers:
803 832 self.matches = matcher(text)
804 833 if self.matches:
805 834 break
806 835 # FIXME: we should extend our api to return a dict with completions for
807 836 # different types of objects. The rlcomplete() method could then
808 837 # simply collapse the dict into a list for readline, but we'd have
809 838 # richer completion semantics in other evironments.
810 839 self.matches = sorted(set(self.matches))
811 840 #io.rprint('COMP TEXT, MATCHES: %r, %r' % (text, self.matches)) # dbg
812 841 return text, self.matches
813 842
814 843 def rlcomplete(self, text, state):
815 844 """Return the state-th possible completion for 'text'.
816 845
817 846 This is called successively with state == 0, 1, 2, ... until it
818 847 returns None. The completion should begin with 'text'.
819 848
820 849 Parameters
821 850 ----------
822 851 text : string
823 852 Text to perform the completion on.
824 853
825 854 state : int
826 855 Counter used by readline.
827 856 """
828 857 if state==0:
829 858
830 859 self.line_buffer = line_buffer = self.readline.get_line_buffer()
831 860 cursor_pos = self.readline.get_endidx()
832 861
833 862 #io.rprint("\nRLCOMPLETE: %r %r %r" %
834 863 # (text, line_buffer, cursor_pos) ) # dbg
835 864
836 865 # if there is only a tab on a line with only whitespace, instead of
837 866 # the mostly useless 'do you want to see all million completions'
838 867 # message, just do the right thing and give the user his tab!
839 868 # Incidentally, this enables pasting of tabbed text from an editor
840 869 # (as long as autoindent is off).
841 870
842 871 # It should be noted that at least pyreadline still shows file
843 872 # completions - is there a way around it?
844 873
845 874 # don't apply this on 'dumb' terminals, such as emacs buffers, so
846 875 # we don't interfere with their own tab-completion mechanism.
847 876 if not (self.dumb_terminal or line_buffer.strip()):
848 877 self.readline.insert_text('\t')
849 878 sys.stdout.flush()
850 879 return None
851 880
852 881 # Note: debugging exceptions that may occur in completion is very
853 882 # tricky, because readline unconditionally silences them. So if
854 883 # during development you suspect a bug in the completion code, turn
855 884 # this flag on temporarily by uncommenting the second form (don't
856 885 # flip the value in the first line, as the '# dbg' marker can be
857 886 # automatically detected and is used elsewhere).
858 887 DEBUG = False
859 888 #DEBUG = True # dbg
860 889 if DEBUG:
861 890 try:
862 891 self.complete(text, line_buffer, cursor_pos)
863 892 except:
864 893 import traceback; traceback.print_exc()
865 894 else:
866 895 # The normal production version is here
867 896
868 897 # This method computes the self.matches array
869 898 self.complete(text, line_buffer, cursor_pos)
870 899
871 900 try:
872 901 return self.matches[state]
873 902 except IndexError:
874 903 return None
@@ -1,2567 +1,2569 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Main IPython class."""
3 3
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 7 # Copyright (C) 2008-2011 The IPython Development Team
8 8 #
9 9 # Distributed under the terms of the BSD License. The full license is in
10 10 # the file COPYING, distributed as part of this software.
11 11 #-----------------------------------------------------------------------------
12 12
13 13 #-----------------------------------------------------------------------------
14 14 # Imports
15 15 #-----------------------------------------------------------------------------
16 16
17 17 from __future__ import with_statement
18 18 from __future__ import absolute_import
19 19
20 20 import __builtin__
21 21 import __future__
22 22 import abc
23 23 import ast
24 24 import atexit
25 25 import codeop
26 26 import inspect
27 27 import os
28 28 import re
29 29 import sys
30 30 import tempfile
31 31 import types
32 32 from contextlib import nested
33 33
34 34 from IPython.config.configurable import SingletonConfigurable
35 35 from IPython.core import debugger, oinspect
36 36 from IPython.core import history as ipcorehist
37 37 from IPython.core import page
38 38 from IPython.core import prefilter
39 39 from IPython.core import shadowns
40 40 from IPython.core import ultratb
41 41 from IPython.core.alias import AliasManager, AliasError
42 42 from IPython.core.autocall import ExitAutocall
43 43 from IPython.core.builtin_trap import BuiltinTrap
44 44 from IPython.core.compilerop import CachingCompiler
45 45 from IPython.core.display_trap import DisplayTrap
46 46 from IPython.core.displayhook import DisplayHook
47 47 from IPython.core.displaypub import DisplayPublisher
48 48 from IPython.core.error import TryNext, UsageError
49 49 from IPython.core.extensions import ExtensionManager
50 50 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
51 51 from IPython.core.formatters import DisplayFormatter
52 52 from IPython.core.history import HistoryManager
53 53 from IPython.core.inputsplitter import IPythonInputSplitter
54 54 from IPython.core.logger import Logger
55 55 from IPython.core.macro import Macro
56 56 from IPython.core.magic import Magic
57 57 from IPython.core.payload import PayloadManager
58 58 from IPython.core.plugin import PluginManager
59 59 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
60 60 from IPython.core.profiledir import ProfileDir
61 61 from IPython.external.Itpl import ItplNS
62 62 from IPython.utils import PyColorize
63 63 from IPython.utils import io
64 64 from IPython.utils.doctestreload import doctest_reload
65 65 from IPython.utils.io import ask_yes_no, rprint
66 66 from IPython.utils.ipstruct import Struct
67 67 from IPython.utils.path import get_home_dir, get_ipython_dir, HomeDirError
68 68 from IPython.utils.pickleshare import PickleShareDB
69 69 from IPython.utils.process import system, getoutput
70 70 from IPython.utils.strdispatch import StrDispatch
71 71 from IPython.utils.syspathcontext import prepended_to_syspath
72 72 from IPython.utils.text import num_ini_spaces, format_screen, LSString, SList
73 73 from IPython.utils.traitlets import (Int, CBool, CaselessStrEnum, Enum,
74 74 List, Unicode, Instance, Type)
75 75 from IPython.utils.warn import warn, error, fatal
76 76 import IPython.core.hooks
77 77
78 78 #-----------------------------------------------------------------------------
79 79 # Globals
80 80 #-----------------------------------------------------------------------------
81 81
82 82 # compiled regexps for autoindent management
83 83 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
84 84
85 85 #-----------------------------------------------------------------------------
86 86 # Utilities
87 87 #-----------------------------------------------------------------------------
88 88
89 89 # store the builtin raw_input globally, and use this always, in case user code
90 90 # overwrites it (like wx.py.PyShell does)
91 91 raw_input_original = raw_input
92 92
93 93 def softspace(file, newvalue):
94 94 """Copied from code.py, to remove the dependency"""
95 95
96 96 oldvalue = 0
97 97 try:
98 98 oldvalue = file.softspace
99 99 except AttributeError:
100 100 pass
101 101 try:
102 102 file.softspace = newvalue
103 103 except (AttributeError, TypeError):
104 104 # "attribute-less object" or "read-only attributes"
105 105 pass
106 106 return oldvalue
107 107
108 108
109 109 def no_op(*a, **kw): pass
110 110
111 111 class SpaceInInput(Exception): pass
112 112
113 113 class Bunch: pass
114 114
115 115
116 116 def get_default_colors():
117 117 if sys.platform=='darwin':
118 118 return "LightBG"
119 119 elif os.name=='nt':
120 120 return 'Linux'
121 121 else:
122 122 return 'Linux'
123 123
124 124
125 125 class SeparateUnicode(Unicode):
126 126 """A Unicode subclass to validate separate_in, separate_out, etc.
127 127
128 128 This is a Unicode based trait that converts '0'->'' and '\\n'->'\n'.
129 129 """
130 130
131 131 def validate(self, obj, value):
132 132 if value == '0': value = ''
133 133 value = value.replace('\\n','\n')
134 134 return super(SeparateUnicode, self).validate(obj, value)
135 135
136 136
137 137 class ReadlineNoRecord(object):
138 138 """Context manager to execute some code, then reload readline history
139 139 so that interactive input to the code doesn't appear when pressing up."""
140 140 def __init__(self, shell):
141 141 self.shell = shell
142 142 self._nested_level = 0
143 143
144 144 def __enter__(self):
145 145 if self._nested_level == 0:
146 146 try:
147 147 self.orig_length = self.current_length()
148 148 self.readline_tail = self.get_readline_tail()
149 149 except (AttributeError, IndexError): # Can fail with pyreadline
150 150 self.orig_length, self.readline_tail = 999999, []
151 151 self._nested_level += 1
152 152
153 153 def __exit__(self, type, value, traceback):
154 154 self._nested_level -= 1
155 155 if self._nested_level == 0:
156 156 # Try clipping the end if it's got longer
157 157 try:
158 158 e = self.current_length() - self.orig_length
159 159 if e > 0:
160 160 for _ in range(e):
161 161 self.shell.readline.remove_history_item(self.orig_length)
162 162
163 163 # If it still doesn't match, just reload readline history.
164 164 if self.current_length() != self.orig_length \
165 165 or self.get_readline_tail() != self.readline_tail:
166 166 self.shell.refill_readline_hist()
167 167 except (AttributeError, IndexError):
168 168 pass
169 169 # Returning False will cause exceptions to propagate
170 170 return False
171 171
172 172 def current_length(self):
173 173 return self.shell.readline.get_current_history_length()
174 174
175 175 def get_readline_tail(self, n=10):
176 176 """Get the last n items in readline history."""
177 177 end = self.shell.readline.get_current_history_length() + 1
178 178 start = max(end-n, 1)
179 179 ghi = self.shell.readline.get_history_item
180 180 return [ghi(x) for x in range(start, end)]
181 181
182 182
183 183 _autocall_help = """
184 184 Make IPython automatically call any callable object even if
185 185 you didn't type explicit parentheses. For example, 'str 43' becomes 'str(43)'
186 186 automatically. The value can be '0' to disable the feature, '1' for 'smart'
187 187 autocall, where it is not applied if there are no more arguments on the line,
188 188 and '2' for 'full' autocall, where all callable objects are automatically
189 189 called (even if no arguments are present). The default is '1'.
190 190 """
191 191
192 192 #-----------------------------------------------------------------------------
193 193 # Main IPython class
194 194 #-----------------------------------------------------------------------------
195 195
196 196 class InteractiveShell(SingletonConfigurable, Magic):
197 197 """An enhanced, interactive shell for Python."""
198 198
199 199 _instance = None
200 200
201 201 autocall = Enum((0,1,2), default_value=1, config=True, help=
202 202 """
203 203 Make IPython automatically call any callable object even if you didn't
204 204 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
205 205 automatically. The value can be '0' to disable the feature, '1' for
206 206 'smart' autocall, where it is not applied if there are no more
207 207 arguments on the line, and '2' for 'full' autocall, where all callable
208 208 objects are automatically called (even if no arguments are present).
209 209 The default is '1'.
210 210 """
211 211 )
212 212 # TODO: remove all autoindent logic and put into frontends.
213 213 # We can't do this yet because even runlines uses the autoindent.
214 214 autoindent = CBool(True, config=True, help=
215 215 """
216 216 Autoindent IPython code entered interactively.
217 217 """
218 218 )
219 219 automagic = CBool(True, config=True, help=
220 220 """
221 221 Enable magic commands to be called without the leading %.
222 222 """
223 223 )
224 224 cache_size = Int(1000, config=True, help=
225 225 """
226 226 Set the size of the output cache. The default is 1000, you can
227 227 change it permanently in your config file. Setting it to 0 completely
228 228 disables the caching system, and the minimum value accepted is 20 (if
229 229 you provide a value less than 20, it is reset to 0 and a warning is
230 230 issued). This limit is defined because otherwise you'll spend more
231 231 time re-flushing a too small cache than working
232 232 """
233 233 )
234 234 color_info = CBool(True, config=True, help=
235 235 """
236 236 Use colors for displaying information about objects. Because this
237 237 information is passed through a pager (like 'less'), and some pagers
238 238 get confused with color codes, this capability can be turned off.
239 239 """
240 240 )
241 241 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
242 242 default_value=get_default_colors(), config=True,
243 243 help="Set the color scheme (NoColor, Linux, or LightBG)."
244 244 )
245 245 debug = CBool(False, config=True)
246 246 deep_reload = CBool(False, config=True, help=
247 247 """
248 248 Enable deep (recursive) reloading by default. IPython can use the
249 249 deep_reload module which reloads changes in modules recursively (it
250 250 replaces the reload() function, so you don't need to change anything to
251 251 use it). deep_reload() forces a full reload of modules whose code may
252 252 have changed, which the default reload() function does not. When
253 253 deep_reload is off, IPython will use the normal reload(), but
254 254 deep_reload will still be available as dreload().
255 255 """
256 256 )
257 257 display_formatter = Instance(DisplayFormatter)
258 258 displayhook_class = Type(DisplayHook)
259 259 display_pub_class = Type(DisplayPublisher)
260 260
261 261 exit_now = CBool(False)
262 262 exiter = Instance(ExitAutocall)
263 263 def _exiter_default(self):
264 264 return ExitAutocall(self)
265 265 # Monotonically increasing execution counter
266 266 execution_count = Int(1)
267 267 filename = Unicode("<ipython console>")
268 268 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
269 269
270 270 # Input splitter, to split entire cells of input into either individual
271 271 # interactive statements or whole blocks.
272 272 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
273 273 (), {})
274 274 logstart = CBool(False, config=True, help=
275 275 """
276 276 Start logging to the default log file.
277 277 """
278 278 )
279 279 logfile = Unicode('', config=True, help=
280 280 """
281 281 The name of the logfile to use.
282 282 """
283 283 )
284 284 logappend = Unicode('', config=True, help=
285 285 """
286 286 Start logging to the given file in append mode.
287 287 """
288 288 )
289 289 object_info_string_level = Enum((0,1,2), default_value=0,
290 290 config=True)
291 291 pdb = CBool(False, config=True, help=
292 292 """
293 293 Automatically call the pdb debugger after every exception.
294 294 """
295 295 )
296 296
297 297 prompt_in1 = Unicode('In [\\#]: ', config=True)
298 298 prompt_in2 = Unicode(' .\\D.: ', config=True)
299 299 prompt_out = Unicode('Out[\\#]: ', config=True)
300 300 prompts_pad_left = CBool(True, config=True)
301 301 quiet = CBool(False, config=True)
302 302
303 303 history_length = Int(10000, config=True)
304 304
305 305 # The readline stuff will eventually be moved to the terminal subclass
306 306 # but for now, we can't do that as readline is welded in everywhere.
307 307 readline_use = CBool(True, config=True)
308 308 readline_merge_completions = CBool(True, config=True)
309 309 readline_omit__names = Enum((0,1,2), default_value=2, config=True)
310 310 readline_remove_delims = Unicode('-/~', config=True)
311 311 # don't use \M- bindings by default, because they
312 312 # conflict with 8-bit encodings. See gh-58,gh-88
313 313 readline_parse_and_bind = List([
314 314 'tab: complete',
315 315 '"\C-l": clear-screen',
316 316 'set show-all-if-ambiguous on',
317 317 '"\C-o": tab-insert',
318 318 '"\C-r": reverse-search-history',
319 319 '"\C-s": forward-search-history',
320 320 '"\C-p": history-search-backward',
321 321 '"\C-n": history-search-forward',
322 322 '"\e[A": history-search-backward',
323 323 '"\e[B": history-search-forward',
324 324 '"\C-k": kill-line',
325 325 '"\C-u": unix-line-discard',
326 326 ], allow_none=False, config=True)
327 327
328 328 # TODO: this part of prompt management should be moved to the frontends.
329 329 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
330 330 separate_in = SeparateUnicode('\n', config=True)
331 331 separate_out = SeparateUnicode('', config=True)
332 332 separate_out2 = SeparateUnicode('', config=True)
333 333 wildcards_case_sensitive = CBool(True, config=True)
334 334 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
335 335 default_value='Context', config=True)
336 336
337 337 # Subcomponents of InteractiveShell
338 338 alias_manager = Instance('IPython.core.alias.AliasManager')
339 339 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
340 340 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
341 341 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
342 342 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
343 343 plugin_manager = Instance('IPython.core.plugin.PluginManager')
344 344 payload_manager = Instance('IPython.core.payload.PayloadManager')
345 345 history_manager = Instance('IPython.core.history.HistoryManager')
346 346
347 347 profile_dir = Instance('IPython.core.application.ProfileDir')
348 348 @property
349 349 def profile(self):
350 350 if self.profile_dir is not None:
351 351 name = os.path.basename(self.profile_dir.location)
352 352 return name.replace('profile_','')
353 353
354 354
355 355 # Private interface
356 356 _post_execute = Instance(dict)
357 357
358 358 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
359 359 user_ns=None, user_global_ns=None,
360 360 custom_exceptions=((), None)):
361 361
362 362 # This is where traits with a config_key argument are updated
363 363 # from the values on config.
364 364 super(InteractiveShell, self).__init__(config=config)
365 365
366 366 # These are relatively independent and stateless
367 367 self.init_ipython_dir(ipython_dir)
368 368 self.init_profile_dir(profile_dir)
369 369 self.init_instance_attrs()
370 370 self.init_environment()
371 371
372 372 # Create namespaces (user_ns, user_global_ns, etc.)
373 373 self.init_create_namespaces(user_ns, user_global_ns)
374 374 # This has to be done after init_create_namespaces because it uses
375 375 # something in self.user_ns, but before init_sys_modules, which
376 376 # is the first thing to modify sys.
377 377 # TODO: When we override sys.stdout and sys.stderr before this class
378 378 # is created, we are saving the overridden ones here. Not sure if this
379 379 # is what we want to do.
380 380 self.save_sys_module_state()
381 381 self.init_sys_modules()
382 382
383 383 # While we're trying to have each part of the code directly access what
384 384 # it needs without keeping redundant references to objects, we have too
385 385 # much legacy code that expects ip.db to exist.
386 386 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
387 387
388 388 self.init_history()
389 389 self.init_encoding()
390 390 self.init_prefilter()
391 391
392 392 Magic.__init__(self, self)
393 393
394 394 self.init_syntax_highlighting()
395 395 self.init_hooks()
396 396 self.init_pushd_popd_magic()
397 397 # self.init_traceback_handlers use to be here, but we moved it below
398 398 # because it and init_io have to come after init_readline.
399 399 self.init_user_ns()
400 400 self.init_logger()
401 401 self.init_alias()
402 402 self.init_builtins()
403 403
404 404 # pre_config_initialization
405 405
406 406 # The next section should contain everything that was in ipmaker.
407 407 self.init_logstart()
408 408
409 409 # The following was in post_config_initialization
410 410 self.init_inspector()
411 411 # init_readline() must come before init_io(), because init_io uses
412 412 # readline related things.
413 413 self.init_readline()
414 414 # init_completer must come after init_readline, because it needs to
415 415 # know whether readline is present or not system-wide to configure the
416 416 # completers, since the completion machinery can now operate
417 417 # independently of readline (e.g. over the network)
418 418 self.init_completer()
419 419 # TODO: init_io() needs to happen before init_traceback handlers
420 420 # because the traceback handlers hardcode the stdout/stderr streams.
421 421 # This logic in in debugger.Pdb and should eventually be changed.
422 422 self.init_io()
423 423 self.init_traceback_handlers(custom_exceptions)
424 424 self.init_prompts()
425 425 self.init_display_formatter()
426 426 self.init_display_pub()
427 427 self.init_displayhook()
428 428 self.init_reload_doctest()
429 429 self.init_magics()
430 430 self.init_pdb()
431 431 self.init_extension_manager()
432 432 self.init_plugin_manager()
433 433 self.init_payload()
434 434 self.hooks.late_startup_hook()
435 435 atexit.register(self.atexit_operations)
436 436
437 437 def get_ipython(self):
438 438 """Return the currently running IPython instance."""
439 439 return self
440 440
441 441 #-------------------------------------------------------------------------
442 442 # Trait changed handlers
443 443 #-------------------------------------------------------------------------
444 444
445 445 def _ipython_dir_changed(self, name, new):
446 446 if not os.path.isdir(new):
447 447 os.makedirs(new, mode = 0777)
448 448
449 449 def set_autoindent(self,value=None):
450 450 """Set the autoindent flag, checking for readline support.
451 451
452 452 If called with no arguments, it acts as a toggle."""
453 453
454 454 if not self.has_readline:
455 455 if os.name == 'posix':
456 456 warn("The auto-indent feature requires the readline library")
457 457 self.autoindent = 0
458 458 return
459 459 if value is None:
460 460 self.autoindent = not self.autoindent
461 461 else:
462 462 self.autoindent = value
463 463
464 464 #-------------------------------------------------------------------------
465 465 # init_* methods called by __init__
466 466 #-------------------------------------------------------------------------
467 467
468 468 def init_ipython_dir(self, ipython_dir):
469 469 if ipython_dir is not None:
470 470 self.ipython_dir = ipython_dir
471 471 return
472 472
473 473 self.ipython_dir = get_ipython_dir()
474 474
475 475 def init_profile_dir(self, profile_dir):
476 476 if profile_dir is not None:
477 477 self.profile_dir = profile_dir
478 478 return
479 479 self.profile_dir =\
480 480 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
481 481
482 482 def init_instance_attrs(self):
483 483 self.more = False
484 484
485 485 # command compiler
486 486 self.compile = CachingCompiler()
487 487
488 488 # Make an empty namespace, which extension writers can rely on both
489 489 # existing and NEVER being used by ipython itself. This gives them a
490 490 # convenient location for storing additional information and state
491 491 # their extensions may require, without fear of collisions with other
492 492 # ipython names that may develop later.
493 493 self.meta = Struct()
494 494
495 495 # Temporary files used for various purposes. Deleted at exit.
496 496 self.tempfiles = []
497 497
498 498 # Keep track of readline usage (later set by init_readline)
499 499 self.has_readline = False
500 500
501 501 # keep track of where we started running (mainly for crash post-mortem)
502 502 # This is not being used anywhere currently.
503 503 self.starting_dir = os.getcwdu()
504 504
505 505 # Indentation management
506 506 self.indent_current_nsp = 0
507 507
508 508 # Dict to track post-execution functions that have been registered
509 509 self._post_execute = {}
510 510
511 511 def init_environment(self):
512 512 """Any changes we need to make to the user's environment."""
513 513 pass
514 514
515 515 def init_encoding(self):
516 516 # Get system encoding at startup time. Certain terminals (like Emacs
517 517 # under Win32 have it set to None, and we need to have a known valid
518 518 # encoding to use in the raw_input() method
519 519 try:
520 520 self.stdin_encoding = sys.stdin.encoding or 'ascii'
521 521 except AttributeError:
522 522 self.stdin_encoding = 'ascii'
523 523
524 524 def init_syntax_highlighting(self):
525 525 # Python source parser/formatter for syntax highlighting
526 526 pyformat = PyColorize.Parser().format
527 527 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
528 528
529 529 def init_pushd_popd_magic(self):
530 530 # for pushd/popd management
531 531 try:
532 532 self.home_dir = get_home_dir()
533 533 except HomeDirError, msg:
534 534 fatal(msg)
535 535
536 536 self.dir_stack = []
537 537
538 538 def init_logger(self):
539 539 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
540 540 logmode='rotate')
541 541
542 542 def init_logstart(self):
543 543 """Initialize logging in case it was requested at the command line.
544 544 """
545 545 if self.logappend:
546 546 self.magic_logstart(self.logappend + ' append')
547 547 elif self.logfile:
548 548 self.magic_logstart(self.logfile)
549 549 elif self.logstart:
550 550 self.magic_logstart()
551 551
552 552 def init_builtins(self):
553 553 self.builtin_trap = BuiltinTrap(shell=self)
554 554
555 555 def init_inspector(self):
556 556 # Object inspector
557 557 self.inspector = oinspect.Inspector(oinspect.InspectColors,
558 558 PyColorize.ANSICodeColors,
559 559 'NoColor',
560 560 self.object_info_string_level)
561 561
562 562 def init_io(self):
563 563 # This will just use sys.stdout and sys.stderr. If you want to
564 564 # override sys.stdout and sys.stderr themselves, you need to do that
565 565 # *before* instantiating this class, because io holds onto
566 566 # references to the underlying streams.
567 567 if sys.platform == 'win32' and self.has_readline:
568 568 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
569 569 else:
570 570 io.stdout = io.IOStream(sys.stdout)
571 571 io.stderr = io.IOStream(sys.stderr)
572 572
573 573 def init_prompts(self):
574 574 # TODO: This is a pass for now because the prompts are managed inside
575 575 # the DisplayHook. Once there is a separate prompt manager, this
576 576 # will initialize that object and all prompt related information.
577 577 pass
578 578
579 579 def init_display_formatter(self):
580 580 self.display_formatter = DisplayFormatter(config=self.config)
581 581
582 582 def init_display_pub(self):
583 583 self.display_pub = self.display_pub_class(config=self.config)
584 584
585 585 def init_displayhook(self):
586 586 # Initialize displayhook, set in/out prompts and printing system
587 587 self.displayhook = self.displayhook_class(
588 588 config=self.config,
589 589 shell=self,
590 590 cache_size=self.cache_size,
591 591 input_sep = self.separate_in,
592 592 output_sep = self.separate_out,
593 593 output_sep2 = self.separate_out2,
594 594 ps1 = self.prompt_in1,
595 595 ps2 = self.prompt_in2,
596 596 ps_out = self.prompt_out,
597 597 pad_left = self.prompts_pad_left
598 598 )
599 599 # This is a context manager that installs/revmoes the displayhook at
600 600 # the appropriate time.
601 601 self.display_trap = DisplayTrap(hook=self.displayhook)
602 602
603 603 def init_reload_doctest(self):
604 604 # Do a proper resetting of doctest, including the necessary displayhook
605 605 # monkeypatching
606 606 try:
607 607 doctest_reload()
608 608 except ImportError:
609 609 warn("doctest module does not exist.")
610 610
611 611 #-------------------------------------------------------------------------
612 612 # Things related to injections into the sys module
613 613 #-------------------------------------------------------------------------
614 614
615 615 def save_sys_module_state(self):
616 616 """Save the state of hooks in the sys module.
617 617
618 618 This has to be called after self.user_ns is created.
619 619 """
620 620 self._orig_sys_module_state = {}
621 621 self._orig_sys_module_state['stdin'] = sys.stdin
622 622 self._orig_sys_module_state['stdout'] = sys.stdout
623 623 self._orig_sys_module_state['stderr'] = sys.stderr
624 624 self._orig_sys_module_state['excepthook'] = sys.excepthook
625 625 try:
626 626 self._orig_sys_modules_main_name = self.user_ns['__name__']
627 627 except KeyError:
628 628 pass
629 629
630 630 def restore_sys_module_state(self):
631 631 """Restore the state of the sys module."""
632 632 try:
633 633 for k, v in self._orig_sys_module_state.iteritems():
634 634 setattr(sys, k, v)
635 635 except AttributeError:
636 636 pass
637 637 # Reset what what done in self.init_sys_modules
638 638 try:
639 639 sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
640 640 except (AttributeError, KeyError):
641 641 pass
642 642
643 643 #-------------------------------------------------------------------------
644 644 # Things related to hooks
645 645 #-------------------------------------------------------------------------
646 646
647 647 def init_hooks(self):
648 648 # hooks holds pointers used for user-side customizations
649 649 self.hooks = Struct()
650 650
651 651 self.strdispatchers = {}
652 652
653 653 # Set all default hooks, defined in the IPython.hooks module.
654 654 hooks = IPython.core.hooks
655 655 for hook_name in hooks.__all__:
656 656 # default hooks have priority 100, i.e. low; user hooks should have
657 657 # 0-100 priority
658 658 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
659 659
660 660 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
661 661 """set_hook(name,hook) -> sets an internal IPython hook.
662 662
663 663 IPython exposes some of its internal API as user-modifiable hooks. By
664 664 adding your function to one of these hooks, you can modify IPython's
665 665 behavior to call at runtime your own routines."""
666 666
667 667 # At some point in the future, this should validate the hook before it
668 668 # accepts it. Probably at least check that the hook takes the number
669 669 # of args it's supposed to.
670 670
671 671 f = types.MethodType(hook,self)
672 672
673 673 # check if the hook is for strdispatcher first
674 674 if str_key is not None:
675 675 sdp = self.strdispatchers.get(name, StrDispatch())
676 676 sdp.add_s(str_key, f, priority )
677 677 self.strdispatchers[name] = sdp
678 678 return
679 679 if re_key is not None:
680 680 sdp = self.strdispatchers.get(name, StrDispatch())
681 681 sdp.add_re(re.compile(re_key), f, priority )
682 682 self.strdispatchers[name] = sdp
683 683 return
684 684
685 685 dp = getattr(self.hooks, name, None)
686 686 if name not in IPython.core.hooks.__all__:
687 687 print "Warning! Hook '%s' is not one of %s" % \
688 688 (name, IPython.core.hooks.__all__ )
689 689 if not dp:
690 690 dp = IPython.core.hooks.CommandChainDispatcher()
691 691
692 692 try:
693 693 dp.add(f,priority)
694 694 except AttributeError:
695 695 # it was not commandchain, plain old func - replace
696 696 dp = f
697 697
698 698 setattr(self.hooks,name, dp)
699 699
700 700 def register_post_execute(self, func):
701 701 """Register a function for calling after code execution.
702 702 """
703 703 if not callable(func):
704 704 raise ValueError('argument %s must be callable' % func)
705 705 self._post_execute[func] = True
706 706
707 707 #-------------------------------------------------------------------------
708 708 # Things related to the "main" module
709 709 #-------------------------------------------------------------------------
710 710
711 711 def new_main_mod(self,ns=None):
712 712 """Return a new 'main' module object for user code execution.
713 713 """
714 714 main_mod = self._user_main_module
715 715 init_fakemod_dict(main_mod,ns)
716 716 return main_mod
717 717
718 718 def cache_main_mod(self,ns,fname):
719 719 """Cache a main module's namespace.
720 720
721 721 When scripts are executed via %run, we must keep a reference to the
722 722 namespace of their __main__ module (a FakeModule instance) around so
723 723 that Python doesn't clear it, rendering objects defined therein
724 724 useless.
725 725
726 726 This method keeps said reference in a private dict, keyed by the
727 727 absolute path of the module object (which corresponds to the script
728 728 path). This way, for multiple executions of the same script we only
729 729 keep one copy of the namespace (the last one), thus preventing memory
730 730 leaks from old references while allowing the objects from the last
731 731 execution to be accessible.
732 732
733 733 Note: we can not allow the actual FakeModule instances to be deleted,
734 734 because of how Python tears down modules (it hard-sets all their
735 735 references to None without regard for reference counts). This method
736 736 must therefore make a *copy* of the given namespace, to allow the
737 737 original module's __dict__ to be cleared and reused.
738 738
739 739
740 740 Parameters
741 741 ----------
742 742 ns : a namespace (a dict, typically)
743 743
744 744 fname : str
745 745 Filename associated with the namespace.
746 746
747 747 Examples
748 748 --------
749 749
750 750 In [10]: import IPython
751 751
752 752 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
753 753
754 754 In [12]: IPython.__file__ in _ip._main_ns_cache
755 755 Out[12]: True
756 756 """
757 757 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
758 758
759 759 def clear_main_mod_cache(self):
760 760 """Clear the cache of main modules.
761 761
762 762 Mainly for use by utilities like %reset.
763 763
764 764 Examples
765 765 --------
766 766
767 767 In [15]: import IPython
768 768
769 769 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
770 770
771 771 In [17]: len(_ip._main_ns_cache) > 0
772 772 Out[17]: True
773 773
774 774 In [18]: _ip.clear_main_mod_cache()
775 775
776 776 In [19]: len(_ip._main_ns_cache) == 0
777 777 Out[19]: True
778 778 """
779 779 self._main_ns_cache.clear()
780 780
781 781 #-------------------------------------------------------------------------
782 782 # Things related to debugging
783 783 #-------------------------------------------------------------------------
784 784
785 785 def init_pdb(self):
786 786 # Set calling of pdb on exceptions
787 787 # self.call_pdb is a property
788 788 self.call_pdb = self.pdb
789 789
790 790 def _get_call_pdb(self):
791 791 return self._call_pdb
792 792
793 793 def _set_call_pdb(self,val):
794 794
795 795 if val not in (0,1,False,True):
796 796 raise ValueError,'new call_pdb value must be boolean'
797 797
798 798 # store value in instance
799 799 self._call_pdb = val
800 800
801 801 # notify the actual exception handlers
802 802 self.InteractiveTB.call_pdb = val
803 803
804 804 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
805 805 'Control auto-activation of pdb at exceptions')
806 806
807 807 def debugger(self,force=False):
808 808 """Call the pydb/pdb debugger.
809 809
810 810 Keywords:
811 811
812 812 - force(False): by default, this routine checks the instance call_pdb
813 813 flag and does not actually invoke the debugger if the flag is false.
814 814 The 'force' option forces the debugger to activate even if the flag
815 815 is false.
816 816 """
817 817
818 818 if not (force or self.call_pdb):
819 819 return
820 820
821 821 if not hasattr(sys,'last_traceback'):
822 822 error('No traceback has been produced, nothing to debug.')
823 823 return
824 824
825 825 # use pydb if available
826 826 if debugger.has_pydb:
827 827 from pydb import pm
828 828 else:
829 829 # fallback to our internal debugger
830 830 pm = lambda : self.InteractiveTB.debugger(force=True)
831 831
832 832 with self.readline_no_record:
833 833 pm()
834 834
835 835 #-------------------------------------------------------------------------
836 836 # Things related to IPython's various namespaces
837 837 #-------------------------------------------------------------------------
838 838
839 839 def init_create_namespaces(self, user_ns=None, user_global_ns=None):
840 840 # Create the namespace where the user will operate. user_ns is
841 841 # normally the only one used, and it is passed to the exec calls as
842 842 # the locals argument. But we do carry a user_global_ns namespace
843 843 # given as the exec 'globals' argument, This is useful in embedding
844 844 # situations where the ipython shell opens in a context where the
845 845 # distinction between locals and globals is meaningful. For
846 846 # non-embedded contexts, it is just the same object as the user_ns dict.
847 847
848 848 # FIXME. For some strange reason, __builtins__ is showing up at user
849 849 # level as a dict instead of a module. This is a manual fix, but I
850 850 # should really track down where the problem is coming from. Alex
851 851 # Schmolck reported this problem first.
852 852
853 853 # A useful post by Alex Martelli on this topic:
854 854 # Re: inconsistent value from __builtins__
855 855 # Von: Alex Martelli <aleaxit@yahoo.com>
856 856 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
857 857 # Gruppen: comp.lang.python
858 858
859 859 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
860 860 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
861 861 # > <type 'dict'>
862 862 # > >>> print type(__builtins__)
863 863 # > <type 'module'>
864 864 # > Is this difference in return value intentional?
865 865
866 866 # Well, it's documented that '__builtins__' can be either a dictionary
867 867 # or a module, and it's been that way for a long time. Whether it's
868 868 # intentional (or sensible), I don't know. In any case, the idea is
869 869 # that if you need to access the built-in namespace directly, you
870 870 # should start with "import __builtin__" (note, no 's') which will
871 871 # definitely give you a module. Yeah, it's somewhat confusing:-(.
872 872
873 873 # These routines return properly built dicts as needed by the rest of
874 874 # the code, and can also be used by extension writers to generate
875 875 # properly initialized namespaces.
876 876 user_ns, user_global_ns = self.make_user_namespaces(user_ns,
877 877 user_global_ns)
878 878
879 879 # Assign namespaces
880 880 # This is the namespace where all normal user variables live
881 881 self.user_ns = user_ns
882 882 self.user_global_ns = user_global_ns
883 883
884 884 # An auxiliary namespace that checks what parts of the user_ns were
885 885 # loaded at startup, so we can list later only variables defined in
886 886 # actual interactive use. Since it is always a subset of user_ns, it
887 887 # doesn't need to be separately tracked in the ns_table.
888 888 self.user_ns_hidden = {}
889 889
890 890 # A namespace to keep track of internal data structures to prevent
891 891 # them from cluttering user-visible stuff. Will be updated later
892 892 self.internal_ns = {}
893 893
894 894 # Now that FakeModule produces a real module, we've run into a nasty
895 895 # problem: after script execution (via %run), the module where the user
896 896 # code ran is deleted. Now that this object is a true module (needed
897 897 # so docetst and other tools work correctly), the Python module
898 898 # teardown mechanism runs over it, and sets to None every variable
899 899 # present in that module. Top-level references to objects from the
900 900 # script survive, because the user_ns is updated with them. However,
901 901 # calling functions defined in the script that use other things from
902 902 # the script will fail, because the function's closure had references
903 903 # to the original objects, which are now all None. So we must protect
904 904 # these modules from deletion by keeping a cache.
905 905 #
906 906 # To avoid keeping stale modules around (we only need the one from the
907 907 # last run), we use a dict keyed with the full path to the script, so
908 908 # only the last version of the module is held in the cache. Note,
909 909 # however, that we must cache the module *namespace contents* (their
910 910 # __dict__). Because if we try to cache the actual modules, old ones
911 911 # (uncached) could be destroyed while still holding references (such as
912 912 # those held by GUI objects that tend to be long-lived)>
913 913 #
914 914 # The %reset command will flush this cache. See the cache_main_mod()
915 915 # and clear_main_mod_cache() methods for details on use.
916 916
917 917 # This is the cache used for 'main' namespaces
918 918 self._main_ns_cache = {}
919 919 # And this is the single instance of FakeModule whose __dict__ we keep
920 920 # copying and clearing for reuse on each %run
921 921 self._user_main_module = FakeModule()
922 922
923 923 # A table holding all the namespaces IPython deals with, so that
924 924 # introspection facilities can search easily.
925 925 self.ns_table = {'user':user_ns,
926 926 'user_global':user_global_ns,
927 927 'internal':self.internal_ns,
928 928 'builtin':__builtin__.__dict__
929 929 }
930 930
931 931 # Similarly, track all namespaces where references can be held and that
932 932 # we can safely clear (so it can NOT include builtin). This one can be
933 933 # a simple list. Note that the main execution namespaces, user_ns and
934 934 # user_global_ns, can NOT be listed here, as clearing them blindly
935 935 # causes errors in object __del__ methods. Instead, the reset() method
936 936 # clears them manually and carefully.
937 937 self.ns_refs_table = [ self.user_ns_hidden,
938 938 self.internal_ns, self._main_ns_cache ]
939 939
940 940 def make_user_namespaces(self, user_ns=None, user_global_ns=None):
941 941 """Return a valid local and global user interactive namespaces.
942 942
943 943 This builds a dict with the minimal information needed to operate as a
944 944 valid IPython user namespace, which you can pass to the various
945 945 embedding classes in ipython. The default implementation returns the
946 946 same dict for both the locals and the globals to allow functions to
947 947 refer to variables in the namespace. Customized implementations can
948 948 return different dicts. The locals dictionary can actually be anything
949 949 following the basic mapping protocol of a dict, but the globals dict
950 950 must be a true dict, not even a subclass. It is recommended that any
951 951 custom object for the locals namespace synchronize with the globals
952 952 dict somehow.
953 953
954 954 Raises TypeError if the provided globals namespace is not a true dict.
955 955
956 956 Parameters
957 957 ----------
958 958 user_ns : dict-like, optional
959 959 The current user namespace. The items in this namespace should
960 960 be included in the output. If None, an appropriate blank
961 961 namespace should be created.
962 962 user_global_ns : dict, optional
963 963 The current user global namespace. The items in this namespace
964 964 should be included in the output. If None, an appropriate
965 965 blank namespace should be created.
966 966
967 967 Returns
968 968 -------
969 969 A pair of dictionary-like object to be used as the local namespace
970 970 of the interpreter and a dict to be used as the global namespace.
971 971 """
972 972
973 973
974 974 # We must ensure that __builtin__ (without the final 's') is always
975 975 # available and pointing to the __builtin__ *module*. For more details:
976 976 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
977 977
978 978 if user_ns is None:
979 979 # Set __name__ to __main__ to better match the behavior of the
980 980 # normal interpreter.
981 981 user_ns = {'__name__' :'__main__',
982 982 '__builtin__' : __builtin__,
983 983 '__builtins__' : __builtin__,
984 984 }
985 985 else:
986 986 user_ns.setdefault('__name__','__main__')
987 987 user_ns.setdefault('__builtin__',__builtin__)
988 988 user_ns.setdefault('__builtins__',__builtin__)
989 989
990 990 if user_global_ns is None:
991 991 user_global_ns = user_ns
992 992 if type(user_global_ns) is not dict:
993 993 raise TypeError("user_global_ns must be a true dict; got %r"
994 994 % type(user_global_ns))
995 995
996 996 return user_ns, user_global_ns
997 997
998 998 def init_sys_modules(self):
999 999 # We need to insert into sys.modules something that looks like a
1000 1000 # module but which accesses the IPython namespace, for shelve and
1001 1001 # pickle to work interactively. Normally they rely on getting
1002 1002 # everything out of __main__, but for embedding purposes each IPython
1003 1003 # instance has its own private namespace, so we can't go shoving
1004 1004 # everything into __main__.
1005 1005
1006 1006 # note, however, that we should only do this for non-embedded
1007 1007 # ipythons, which really mimic the __main__.__dict__ with their own
1008 1008 # namespace. Embedded instances, on the other hand, should not do
1009 1009 # this because they need to manage the user local/global namespaces
1010 1010 # only, but they live within a 'normal' __main__ (meaning, they
1011 1011 # shouldn't overtake the execution environment of the script they're
1012 1012 # embedded in).
1013 1013
1014 1014 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1015 1015
1016 1016 try:
1017 1017 main_name = self.user_ns['__name__']
1018 1018 except KeyError:
1019 1019 raise KeyError('user_ns dictionary MUST have a "__name__" key')
1020 1020 else:
1021 1021 sys.modules[main_name] = FakeModule(self.user_ns)
1022 1022
1023 1023 def init_user_ns(self):
1024 1024 """Initialize all user-visible namespaces to their minimum defaults.
1025 1025
1026 1026 Certain history lists are also initialized here, as they effectively
1027 1027 act as user namespaces.
1028 1028
1029 1029 Notes
1030 1030 -----
1031 1031 All data structures here are only filled in, they are NOT reset by this
1032 1032 method. If they were not empty before, data will simply be added to
1033 1033 therm.
1034 1034 """
1035 1035 # This function works in two parts: first we put a few things in
1036 1036 # user_ns, and we sync that contents into user_ns_hidden so that these
1037 1037 # initial variables aren't shown by %who. After the sync, we add the
1038 1038 # rest of what we *do* want the user to see with %who even on a new
1039 1039 # session (probably nothing, so theye really only see their own stuff)
1040 1040
1041 1041 # The user dict must *always* have a __builtin__ reference to the
1042 1042 # Python standard __builtin__ namespace, which must be imported.
1043 1043 # This is so that certain operations in prompt evaluation can be
1044 1044 # reliably executed with builtins. Note that we can NOT use
1045 1045 # __builtins__ (note the 's'), because that can either be a dict or a
1046 1046 # module, and can even mutate at runtime, depending on the context
1047 1047 # (Python makes no guarantees on it). In contrast, __builtin__ is
1048 1048 # always a module object, though it must be explicitly imported.
1049 1049
1050 1050 # For more details:
1051 1051 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1052 1052 ns = dict(__builtin__ = __builtin__)
1053 1053
1054 1054 # Put 'help' in the user namespace
1055 1055 try:
1056 1056 from site import _Helper
1057 1057 ns['help'] = _Helper()
1058 1058 except ImportError:
1059 1059 warn('help() not available - check site.py')
1060 1060
1061 1061 # make global variables for user access to the histories
1062 1062 ns['_ih'] = self.history_manager.input_hist_parsed
1063 1063 ns['_oh'] = self.history_manager.output_hist
1064 1064 ns['_dh'] = self.history_manager.dir_hist
1065 1065
1066 1066 ns['_sh'] = shadowns
1067 1067
1068 1068 # user aliases to input and output histories. These shouldn't show up
1069 1069 # in %who, as they can have very large reprs.
1070 1070 ns['In'] = self.history_manager.input_hist_parsed
1071 1071 ns['Out'] = self.history_manager.output_hist
1072 1072
1073 1073 # Store myself as the public api!!!
1074 1074 ns['get_ipython'] = self.get_ipython
1075 1075
1076 1076 ns['exit'] = self.exiter
1077 1077 ns['quit'] = self.exiter
1078 1078
1079 1079 # Sync what we've added so far to user_ns_hidden so these aren't seen
1080 1080 # by %who
1081 1081 self.user_ns_hidden.update(ns)
1082 1082
1083 1083 # Anything put into ns now would show up in %who. Think twice before
1084 1084 # putting anything here, as we really want %who to show the user their
1085 1085 # stuff, not our variables.
1086 1086
1087 1087 # Finally, update the real user's namespace
1088 1088 self.user_ns.update(ns)
1089 1089
1090 1090 def reset(self, new_session=True):
1091 1091 """Clear all internal namespaces, and attempt to release references to
1092 1092 user objects.
1093 1093
1094 1094 If new_session is True, a new history session will be opened.
1095 1095 """
1096 1096 # Clear histories
1097 1097 self.history_manager.reset(new_session)
1098 1098 # Reset counter used to index all histories
1099 1099 if new_session:
1100 1100 self.execution_count = 1
1101 1101
1102 1102 # Flush cached output items
1103 1103 if self.displayhook.do_full_cache:
1104 1104 self.displayhook.flush()
1105 1105
1106 1106 # Restore the user namespaces to minimal usability
1107 1107 for ns in self.ns_refs_table:
1108 1108 ns.clear()
1109 1109
1110 1110 # The main execution namespaces must be cleared very carefully,
1111 1111 # skipping the deletion of the builtin-related keys, because doing so
1112 1112 # would cause errors in many object's __del__ methods.
1113 1113 for ns in [self.user_ns, self.user_global_ns]:
1114 1114 drop_keys = set(ns.keys())
1115 1115 drop_keys.discard('__builtin__')
1116 1116 drop_keys.discard('__builtins__')
1117 1117 for k in drop_keys:
1118 1118 del ns[k]
1119 1119
1120 1120 # Restore the user namespaces to minimal usability
1121 1121 self.init_user_ns()
1122 1122
1123 1123 # Restore the default and user aliases
1124 1124 self.alias_manager.clear_aliases()
1125 1125 self.alias_manager.init_aliases()
1126 1126
1127 1127 # Flush the private list of module references kept for script
1128 1128 # execution protection
1129 1129 self.clear_main_mod_cache()
1130 1130
1131 1131 # Clear out the namespace from the last %run
1132 1132 self.new_main_mod()
1133 1133
1134 1134 def del_var(self, varname, by_name=False):
1135 1135 """Delete a variable from the various namespaces, so that, as
1136 1136 far as possible, we're not keeping any hidden references to it.
1137 1137
1138 1138 Parameters
1139 1139 ----------
1140 1140 varname : str
1141 1141 The name of the variable to delete.
1142 1142 by_name : bool
1143 1143 If True, delete variables with the given name in each
1144 1144 namespace. If False (default), find the variable in the user
1145 1145 namespace, and delete references to it.
1146 1146 """
1147 1147 if varname in ('__builtin__', '__builtins__'):
1148 1148 raise ValueError("Refusing to delete %s" % varname)
1149 1149 ns_refs = self.ns_refs_table + [self.user_ns,
1150 1150 self.user_global_ns, self._user_main_module.__dict__] +\
1151 1151 self._main_ns_cache.values()
1152 1152
1153 1153 if by_name: # Delete by name
1154 1154 for ns in ns_refs:
1155 1155 try:
1156 1156 del ns[varname]
1157 1157 except KeyError:
1158 1158 pass
1159 1159 else: # Delete by object
1160 1160 try:
1161 1161 obj = self.user_ns[varname]
1162 1162 except KeyError:
1163 1163 raise NameError("name '%s' is not defined" % varname)
1164 1164 # Also check in output history
1165 1165 ns_refs.append(self.history_manager.output_hist)
1166 1166 for ns in ns_refs:
1167 1167 to_delete = [n for n, o in ns.iteritems() if o is obj]
1168 1168 for name in to_delete:
1169 1169 del ns[name]
1170 1170
1171 1171 # displayhook keeps extra references, but not in a dictionary
1172 1172 for name in ('_', '__', '___'):
1173 1173 if getattr(self.displayhook, name) is obj:
1174 1174 setattr(self.displayhook, name, None)
1175 1175
1176 1176 def reset_selective(self, regex=None):
1177 1177 """Clear selective variables from internal namespaces based on a
1178 1178 specified regular expression.
1179 1179
1180 1180 Parameters
1181 1181 ----------
1182 1182 regex : string or compiled pattern, optional
1183 1183 A regular expression pattern that will be used in searching
1184 1184 variable names in the users namespaces.
1185 1185 """
1186 1186 if regex is not None:
1187 1187 try:
1188 1188 m = re.compile(regex)
1189 1189 except TypeError:
1190 1190 raise TypeError('regex must be a string or compiled pattern')
1191 1191 # Search for keys in each namespace that match the given regex
1192 1192 # If a match is found, delete the key/value pair.
1193 1193 for ns in self.ns_refs_table:
1194 1194 for var in ns:
1195 1195 if m.search(var):
1196 1196 del ns[var]
1197 1197
1198 1198 def push(self, variables, interactive=True):
1199 1199 """Inject a group of variables into the IPython user namespace.
1200 1200
1201 1201 Parameters
1202 1202 ----------
1203 1203 variables : dict, str or list/tuple of str
1204 1204 The variables to inject into the user's namespace. If a dict, a
1205 1205 simple update is done. If a str, the string is assumed to have
1206 1206 variable names separated by spaces. A list/tuple of str can also
1207 1207 be used to give the variable names. If just the variable names are
1208 1208 give (list/tuple/str) then the variable values looked up in the
1209 1209 callers frame.
1210 1210 interactive : bool
1211 1211 If True (default), the variables will be listed with the ``who``
1212 1212 magic.
1213 1213 """
1214 1214 vdict = None
1215 1215
1216 1216 # We need a dict of name/value pairs to do namespace updates.
1217 1217 if isinstance(variables, dict):
1218 1218 vdict = variables
1219 1219 elif isinstance(variables, (basestring, list, tuple)):
1220 1220 if isinstance(variables, basestring):
1221 1221 vlist = variables.split()
1222 1222 else:
1223 1223 vlist = variables
1224 1224 vdict = {}
1225 1225 cf = sys._getframe(1)
1226 1226 for name in vlist:
1227 1227 try:
1228 1228 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1229 1229 except:
1230 1230 print ('Could not get variable %s from %s' %
1231 1231 (name,cf.f_code.co_name))
1232 1232 else:
1233 1233 raise ValueError('variables must be a dict/str/list/tuple')
1234 1234
1235 1235 # Propagate variables to user namespace
1236 1236 self.user_ns.update(vdict)
1237 1237
1238 1238 # And configure interactive visibility
1239 1239 config_ns = self.user_ns_hidden
1240 1240 if interactive:
1241 1241 for name, val in vdict.iteritems():
1242 1242 config_ns.pop(name, None)
1243 1243 else:
1244 1244 for name,val in vdict.iteritems():
1245 1245 config_ns[name] = val
1246 1246
1247 1247 #-------------------------------------------------------------------------
1248 1248 # Things related to object introspection
1249 1249 #-------------------------------------------------------------------------
1250 1250
1251 1251 def _ofind(self, oname, namespaces=None):
1252 1252 """Find an object in the available namespaces.
1253 1253
1254 1254 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1255 1255
1256 1256 Has special code to detect magic functions.
1257 1257 """
1258 1258 #oname = oname.strip()
1259 1259 #print '1- oname: <%r>' % oname # dbg
1260 1260 try:
1261 1261 oname = oname.strip().encode('ascii')
1262 1262 #print '2- oname: <%r>' % oname # dbg
1263 1263 except UnicodeEncodeError:
1264 1264 print 'Python identifiers can only contain ascii characters.'
1265 1265 return dict(found=False)
1266 1266
1267 1267 alias_ns = None
1268 1268 if namespaces is None:
1269 1269 # Namespaces to search in:
1270 1270 # Put them in a list. The order is important so that we
1271 1271 # find things in the same order that Python finds them.
1272 1272 namespaces = [ ('Interactive', self.user_ns),
1273 1273 ('IPython internal', self.internal_ns),
1274 1274 ('Python builtin', __builtin__.__dict__),
1275 1275 ('Alias', self.alias_manager.alias_table),
1276 1276 ]
1277 1277 alias_ns = self.alias_manager.alias_table
1278 1278
1279 1279 # initialize results to 'null'
1280 1280 found = False; obj = None; ospace = None; ds = None;
1281 1281 ismagic = False; isalias = False; parent = None
1282 1282
1283 1283 # We need to special-case 'print', which as of python2.6 registers as a
1284 1284 # function but should only be treated as one if print_function was
1285 1285 # loaded with a future import. In this case, just bail.
1286 1286 if (oname == 'print' and not (self.compile.compiler_flags &
1287 1287 __future__.CO_FUTURE_PRINT_FUNCTION)):
1288 1288 return {'found':found, 'obj':obj, 'namespace':ospace,
1289 1289 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1290 1290
1291 1291 # Look for the given name by splitting it in parts. If the head is
1292 1292 # found, then we look for all the remaining parts as members, and only
1293 1293 # declare success if we can find them all.
1294 1294 oname_parts = oname.split('.')
1295 1295 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1296 1296 for nsname,ns in namespaces:
1297 1297 try:
1298 1298 obj = ns[oname_head]
1299 1299 except KeyError:
1300 1300 continue
1301 1301 else:
1302 1302 #print 'oname_rest:', oname_rest # dbg
1303 1303 for part in oname_rest:
1304 1304 try:
1305 1305 parent = obj
1306 1306 obj = getattr(obj,part)
1307 1307 except:
1308 1308 # Blanket except b/c some badly implemented objects
1309 1309 # allow __getattr__ to raise exceptions other than
1310 1310 # AttributeError, which then crashes IPython.
1311 1311 break
1312 1312 else:
1313 1313 # If we finish the for loop (no break), we got all members
1314 1314 found = True
1315 1315 ospace = nsname
1316 1316 if ns == alias_ns:
1317 1317 isalias = True
1318 1318 break # namespace loop
1319 1319
1320 1320 # Try to see if it's magic
1321 1321 if not found:
1322 1322 if oname.startswith(ESC_MAGIC):
1323 1323 oname = oname[1:]
1324 1324 obj = getattr(self,'magic_'+oname,None)
1325 1325 if obj is not None:
1326 1326 found = True
1327 1327 ospace = 'IPython internal'
1328 1328 ismagic = True
1329 1329
1330 1330 # Last try: special-case some literals like '', [], {}, etc:
1331 1331 if not found and oname_head in ["''",'""','[]','{}','()']:
1332 1332 obj = eval(oname_head)
1333 1333 found = True
1334 1334 ospace = 'Interactive'
1335 1335
1336 1336 return {'found':found, 'obj':obj, 'namespace':ospace,
1337 1337 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1338 1338
1339 1339 def _ofind_property(self, oname, info):
1340 1340 """Second part of object finding, to look for property details."""
1341 1341 if info.found:
1342 1342 # Get the docstring of the class property if it exists.
1343 1343 path = oname.split('.')
1344 1344 root = '.'.join(path[:-1])
1345 1345 if info.parent is not None:
1346 1346 try:
1347 1347 target = getattr(info.parent, '__class__')
1348 1348 # The object belongs to a class instance.
1349 1349 try:
1350 1350 target = getattr(target, path[-1])
1351 1351 # The class defines the object.
1352 1352 if isinstance(target, property):
1353 1353 oname = root + '.__class__.' + path[-1]
1354 1354 info = Struct(self._ofind(oname))
1355 1355 except AttributeError: pass
1356 1356 except AttributeError: pass
1357 1357
1358 1358 # We return either the new info or the unmodified input if the object
1359 1359 # hadn't been found
1360 1360 return info
1361 1361
1362 1362 def _object_find(self, oname, namespaces=None):
1363 1363 """Find an object and return a struct with info about it."""
1364 1364 inf = Struct(self._ofind(oname, namespaces))
1365 1365 return Struct(self._ofind_property(oname, inf))
1366 1366
1367 1367 def _inspect(self, meth, oname, namespaces=None, **kw):
1368 1368 """Generic interface to the inspector system.
1369 1369
1370 1370 This function is meant to be called by pdef, pdoc & friends."""
1371 1371 info = self._object_find(oname)
1372 1372 if info.found:
1373 1373 pmethod = getattr(self.inspector, meth)
1374 1374 formatter = format_screen if info.ismagic else None
1375 1375 if meth == 'pdoc':
1376 1376 pmethod(info.obj, oname, formatter)
1377 1377 elif meth == 'pinfo':
1378 1378 pmethod(info.obj, oname, formatter, info, **kw)
1379 1379 else:
1380 1380 pmethod(info.obj, oname)
1381 1381 else:
1382 1382 print 'Object `%s` not found.' % oname
1383 1383 return 'not found' # so callers can take other action
1384 1384
1385 1385 def object_inspect(self, oname):
1386 1386 with self.builtin_trap:
1387 1387 info = self._object_find(oname)
1388 1388 if info.found:
1389 1389 return self.inspector.info(info.obj, oname, info=info)
1390 1390 else:
1391 1391 return oinspect.object_info(name=oname, found=False)
1392 1392
1393 1393 #-------------------------------------------------------------------------
1394 1394 # Things related to history management
1395 1395 #-------------------------------------------------------------------------
1396 1396
1397 1397 def init_history(self):
1398 1398 """Sets up the command history, and starts regular autosaves."""
1399 1399 self.history_manager = HistoryManager(shell=self, config=self.config)
1400 1400
1401 1401 #-------------------------------------------------------------------------
1402 1402 # Things related to exception handling and tracebacks (not debugging)
1403 1403 #-------------------------------------------------------------------------
1404 1404
1405 1405 def init_traceback_handlers(self, custom_exceptions):
1406 1406 # Syntax error handler.
1407 1407 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1408 1408
1409 1409 # The interactive one is initialized with an offset, meaning we always
1410 1410 # want to remove the topmost item in the traceback, which is our own
1411 1411 # internal code. Valid modes: ['Plain','Context','Verbose']
1412 1412 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1413 1413 color_scheme='NoColor',
1414 1414 tb_offset = 1,
1415 1415 check_cache=self.compile.check_cache)
1416 1416
1417 1417 # The instance will store a pointer to the system-wide exception hook,
1418 1418 # so that runtime code (such as magics) can access it. This is because
1419 1419 # during the read-eval loop, it may get temporarily overwritten.
1420 1420 self.sys_excepthook = sys.excepthook
1421 1421
1422 1422 # and add any custom exception handlers the user may have specified
1423 1423 self.set_custom_exc(*custom_exceptions)
1424 1424
1425 1425 # Set the exception mode
1426 1426 self.InteractiveTB.set_mode(mode=self.xmode)
1427 1427
1428 1428 def set_custom_exc(self, exc_tuple, handler):
1429 1429 """set_custom_exc(exc_tuple,handler)
1430 1430
1431 1431 Set a custom exception handler, which will be called if any of the
1432 1432 exceptions in exc_tuple occur in the mainloop (specifically, in the
1433 1433 run_code() method.
1434 1434
1435 1435 Inputs:
1436 1436
1437 1437 - exc_tuple: a *tuple* of valid exceptions to call the defined
1438 1438 handler for. It is very important that you use a tuple, and NOT A
1439 1439 LIST here, because of the way Python's except statement works. If
1440 1440 you only want to trap a single exception, use a singleton tuple:
1441 1441
1442 1442 exc_tuple == (MyCustomException,)
1443 1443
1444 1444 - handler: this must be defined as a function with the following
1445 1445 basic interface::
1446 1446
1447 1447 def my_handler(self, etype, value, tb, tb_offset=None)
1448 1448 ...
1449 1449 # The return value must be
1450 1450 return structured_traceback
1451 1451
1452 1452 This will be made into an instance method (via types.MethodType)
1453 1453 of IPython itself, and it will be called if any of the exceptions
1454 1454 listed in the exc_tuple are caught. If the handler is None, an
1455 1455 internal basic one is used, which just prints basic info.
1456 1456
1457 1457 WARNING: by putting in your own exception handler into IPython's main
1458 1458 execution loop, you run a very good chance of nasty crashes. This
1459 1459 facility should only be used if you really know what you are doing."""
1460 1460
1461 1461 assert type(exc_tuple)==type(()) , \
1462 1462 "The custom exceptions must be given AS A TUPLE."
1463 1463
1464 1464 def dummy_handler(self,etype,value,tb):
1465 1465 print '*** Simple custom exception handler ***'
1466 1466 print 'Exception type :',etype
1467 1467 print 'Exception value:',value
1468 1468 print 'Traceback :',tb
1469 1469 #print 'Source code :','\n'.join(self.buffer)
1470 1470
1471 1471 if handler is None: handler = dummy_handler
1472 1472
1473 1473 self.CustomTB = types.MethodType(handler,self)
1474 1474 self.custom_exceptions = exc_tuple
1475 1475
1476 1476 def excepthook(self, etype, value, tb):
1477 1477 """One more defense for GUI apps that call sys.excepthook.
1478 1478
1479 1479 GUI frameworks like wxPython trap exceptions and call
1480 1480 sys.excepthook themselves. I guess this is a feature that
1481 1481 enables them to keep running after exceptions that would
1482 1482 otherwise kill their mainloop. This is a bother for IPython
1483 1483 which excepts to catch all of the program exceptions with a try:
1484 1484 except: statement.
1485 1485
1486 1486 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1487 1487 any app directly invokes sys.excepthook, it will look to the user like
1488 1488 IPython crashed. In order to work around this, we can disable the
1489 1489 CrashHandler and replace it with this excepthook instead, which prints a
1490 1490 regular traceback using our InteractiveTB. In this fashion, apps which
1491 1491 call sys.excepthook will generate a regular-looking exception from
1492 1492 IPython, and the CrashHandler will only be triggered by real IPython
1493 1493 crashes.
1494 1494
1495 1495 This hook should be used sparingly, only in places which are not likely
1496 1496 to be true IPython errors.
1497 1497 """
1498 1498 self.showtraceback((etype,value,tb),tb_offset=0)
1499 1499
1500 1500 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1501 1501 exception_only=False):
1502 1502 """Display the exception that just occurred.
1503 1503
1504 1504 If nothing is known about the exception, this is the method which
1505 1505 should be used throughout the code for presenting user tracebacks,
1506 1506 rather than directly invoking the InteractiveTB object.
1507 1507
1508 1508 A specific showsyntaxerror() also exists, but this method can take
1509 1509 care of calling it if needed, so unless you are explicitly catching a
1510 1510 SyntaxError exception, don't try to analyze the stack manually and
1511 1511 simply call this method."""
1512 1512
1513 1513 try:
1514 1514 if exc_tuple is None:
1515 1515 etype, value, tb = sys.exc_info()
1516 1516 else:
1517 1517 etype, value, tb = exc_tuple
1518 1518
1519 1519 if etype is None:
1520 1520 if hasattr(sys, 'last_type'):
1521 1521 etype, value, tb = sys.last_type, sys.last_value, \
1522 1522 sys.last_traceback
1523 1523 else:
1524 1524 self.write_err('No traceback available to show.\n')
1525 1525 return
1526 1526
1527 1527 if etype is SyntaxError:
1528 1528 # Though this won't be called by syntax errors in the input
1529 1529 # line, there may be SyntaxError cases whith imported code.
1530 1530 self.showsyntaxerror(filename)
1531 1531 elif etype is UsageError:
1532 1532 print "UsageError:", value
1533 1533 else:
1534 1534 # WARNING: these variables are somewhat deprecated and not
1535 1535 # necessarily safe to use in a threaded environment, but tools
1536 1536 # like pdb depend on their existence, so let's set them. If we
1537 1537 # find problems in the field, we'll need to revisit their use.
1538 1538 sys.last_type = etype
1539 1539 sys.last_value = value
1540 1540 sys.last_traceback = tb
1541 1541 if etype in self.custom_exceptions:
1542 1542 # FIXME: Old custom traceback objects may just return a
1543 1543 # string, in that case we just put it into a list
1544 1544 stb = self.CustomTB(etype, value, tb, tb_offset)
1545 1545 if isinstance(ctb, basestring):
1546 1546 stb = [stb]
1547 1547 else:
1548 1548 if exception_only:
1549 1549 stb = ['An exception has occurred, use %tb to see '
1550 1550 'the full traceback.\n']
1551 1551 stb.extend(self.InteractiveTB.get_exception_only(etype,
1552 1552 value))
1553 1553 else:
1554 1554 stb = self.InteractiveTB.structured_traceback(etype,
1555 1555 value, tb, tb_offset=tb_offset)
1556 1556
1557 1557 if self.call_pdb:
1558 1558 # drop into debugger
1559 1559 self.debugger(force=True)
1560 1560
1561 1561 # Actually show the traceback
1562 1562 self._showtraceback(etype, value, stb)
1563 1563
1564 1564 except KeyboardInterrupt:
1565 1565 self.write_err("\nKeyboardInterrupt\n")
1566 1566
1567 1567 def _showtraceback(self, etype, evalue, stb):
1568 1568 """Actually show a traceback.
1569 1569
1570 1570 Subclasses may override this method to put the traceback on a different
1571 1571 place, like a side channel.
1572 1572 """
1573 1573 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1574 1574
1575 1575 def showsyntaxerror(self, filename=None):
1576 1576 """Display the syntax error that just occurred.
1577 1577
1578 1578 This doesn't display a stack trace because there isn't one.
1579 1579
1580 1580 If a filename is given, it is stuffed in the exception instead
1581 1581 of what was there before (because Python's parser always uses
1582 1582 "<string>" when reading from a string).
1583 1583 """
1584 1584 etype, value, last_traceback = sys.exc_info()
1585 1585
1586 1586 # See note about these variables in showtraceback() above
1587 1587 sys.last_type = etype
1588 1588 sys.last_value = value
1589 1589 sys.last_traceback = last_traceback
1590 1590
1591 1591 if filename and etype is SyntaxError:
1592 1592 # Work hard to stuff the correct filename in the exception
1593 1593 try:
1594 1594 msg, (dummy_filename, lineno, offset, line) = value
1595 1595 except:
1596 1596 # Not the format we expect; leave it alone
1597 1597 pass
1598 1598 else:
1599 1599 # Stuff in the right filename
1600 1600 try:
1601 1601 # Assume SyntaxError is a class exception
1602 1602 value = SyntaxError(msg, (filename, lineno, offset, line))
1603 1603 except:
1604 1604 # If that failed, assume SyntaxError is a string
1605 1605 value = msg, (filename, lineno, offset, line)
1606 1606 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1607 1607 self._showtraceback(etype, value, stb)
1608 1608
1609 1609 # This is overridden in TerminalInteractiveShell to show a message about
1610 1610 # the %paste magic.
1611 1611 def showindentationerror(self):
1612 1612 """Called by run_cell when there's an IndentationError in code entered
1613 1613 at the prompt.
1614 1614
1615 1615 This is overridden in TerminalInteractiveShell to show a message about
1616 1616 the %paste magic."""
1617 1617 self.showsyntaxerror()
1618 1618
1619 1619 #-------------------------------------------------------------------------
1620 1620 # Things related to readline
1621 1621 #-------------------------------------------------------------------------
1622 1622
1623 1623 def init_readline(self):
1624 1624 """Command history completion/saving/reloading."""
1625 1625
1626 1626 if self.readline_use:
1627 1627 import IPython.utils.rlineimpl as readline
1628 1628
1629 1629 self.rl_next_input = None
1630 1630 self.rl_do_indent = False
1631 1631
1632 1632 if not self.readline_use or not readline.have_readline:
1633 1633 self.has_readline = False
1634 1634 self.readline = None
1635 1635 # Set a number of methods that depend on readline to be no-op
1636 1636 self.set_readline_completer = no_op
1637 1637 self.set_custom_completer = no_op
1638 1638 self.set_completer_frame = no_op
1639 1639 warn('Readline services not available or not loaded.')
1640 1640 else:
1641 1641 self.has_readline = True
1642 1642 self.readline = readline
1643 1643 sys.modules['readline'] = readline
1644 1644
1645 1645 # Platform-specific configuration
1646 1646 if os.name == 'nt':
1647 1647 # FIXME - check with Frederick to see if we can harmonize
1648 1648 # naming conventions with pyreadline to avoid this
1649 1649 # platform-dependent check
1650 1650 self.readline_startup_hook = readline.set_pre_input_hook
1651 1651 else:
1652 1652 self.readline_startup_hook = readline.set_startup_hook
1653 1653
1654 1654 # Load user's initrc file (readline config)
1655 1655 # Or if libedit is used, load editrc.
1656 1656 inputrc_name = os.environ.get('INPUTRC')
1657 1657 if inputrc_name is None:
1658 1658 home_dir = get_home_dir()
1659 1659 if home_dir is not None:
1660 1660 inputrc_name = '.inputrc'
1661 1661 if readline.uses_libedit:
1662 1662 inputrc_name = '.editrc'
1663 1663 inputrc_name = os.path.join(home_dir, inputrc_name)
1664 1664 if os.path.isfile(inputrc_name):
1665 1665 try:
1666 1666 readline.read_init_file(inputrc_name)
1667 1667 except:
1668 1668 warn('Problems reading readline initialization file <%s>'
1669 1669 % inputrc_name)
1670 1670
1671 1671 # Configure readline according to user's prefs
1672 1672 # This is only done if GNU readline is being used. If libedit
1673 1673 # is being used (as on Leopard) the readline config is
1674 1674 # not run as the syntax for libedit is different.
1675 1675 if not readline.uses_libedit:
1676 1676 for rlcommand in self.readline_parse_and_bind:
1677 1677 #print "loading rl:",rlcommand # dbg
1678 1678 readline.parse_and_bind(rlcommand)
1679 1679
1680 1680 # Remove some chars from the delimiters list. If we encounter
1681 1681 # unicode chars, discard them.
1682 1682 delims = readline.get_completer_delims().encode("ascii", "ignore")
1683 1683 for d in self.readline_remove_delims:
1684 1684 delims = delims.replace(d, "")
1685 1685 delims = delims.replace(ESC_MAGIC, '')
1686 1686 readline.set_completer_delims(delims)
1687 1687 # otherwise we end up with a monster history after a while:
1688 1688 readline.set_history_length(self.history_length)
1689 1689
1690 1690 self.refill_readline_hist()
1691 1691 self.readline_no_record = ReadlineNoRecord(self)
1692 1692
1693 1693 # Configure auto-indent for all platforms
1694 1694 self.set_autoindent(self.autoindent)
1695 1695
1696 1696 def refill_readline_hist(self):
1697 1697 # Load the last 1000 lines from history
1698 1698 self.readline.clear_history()
1699 1699 stdin_encoding = sys.stdin.encoding or "utf-8"
1700 1700 for _, _, cell in self.history_manager.get_tail(1000,
1701 1701 include_latest=True):
1702 1702 if cell.strip(): # Ignore blank lines
1703 1703 for line in cell.splitlines():
1704 1704 self.readline.add_history(line.encode(stdin_encoding, 'replace'))
1705 1705
1706 1706 def set_next_input(self, s):
1707 1707 """ Sets the 'default' input string for the next command line.
1708 1708
1709 1709 Requires readline.
1710 1710
1711 1711 Example:
1712 1712
1713 1713 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1714 1714 [D:\ipython]|2> Hello Word_ # cursor is here
1715 1715 """
1716 1716 if isinstance(s, unicode):
1717 1717 s = s.encode(self.stdin_encoding, 'replace')
1718 1718 self.rl_next_input = s
1719 1719
1720 1720 # Maybe move this to the terminal subclass?
1721 1721 def pre_readline(self):
1722 1722 """readline hook to be used at the start of each line.
1723 1723
1724 1724 Currently it handles auto-indent only."""
1725 1725
1726 1726 if self.rl_do_indent:
1727 1727 self.readline.insert_text(self._indent_current_str())
1728 1728 if self.rl_next_input is not None:
1729 1729 self.readline.insert_text(self.rl_next_input)
1730 1730 self.rl_next_input = None
1731 1731
1732 1732 def _indent_current_str(self):
1733 1733 """return the current level of indentation as a string"""
1734 1734 return self.input_splitter.indent_spaces * ' '
1735 1735
1736 1736 #-------------------------------------------------------------------------
1737 1737 # Things related to text completion
1738 1738 #-------------------------------------------------------------------------
1739 1739
1740 1740 def init_completer(self):
1741 1741 """Initialize the completion machinery.
1742 1742
1743 1743 This creates completion machinery that can be used by client code,
1744 1744 either interactively in-process (typically triggered by the readline
1745 1745 library), programatically (such as in test suites) or out-of-prcess
1746 1746 (typically over the network by remote frontends).
1747 1747 """
1748 1748 from IPython.core.completer import IPCompleter
1749 1749 from IPython.core.completerlib import (module_completer,
1750 1750 magic_run_completer, cd_completer)
1751 1751
1752 self.Completer = IPCompleter(self,
1753 self.user_ns,
1754 self.user_global_ns,
1755 self.readline_omit__names,
1756 self.alias_manager.alias_table,
1757 self.has_readline)
1752 self.Completer = IPCompleter(shell=self,
1753 namespace=self.user_ns,
1754 global_namespace=self.user_global_ns,
1755 omit__names=self.readline_omit__names,
1756 alias_table=self.alias_manager.alias_table,
1757 use_readline=self.has_readline,
1758 config=self.config,
1759 )
1758 1760
1759 1761 # Add custom completers to the basic ones built into IPCompleter
1760 1762 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1761 1763 self.strdispatchers['complete_command'] = sdisp
1762 1764 self.Completer.custom_completers = sdisp
1763 1765
1764 1766 self.set_hook('complete_command', module_completer, str_key = 'import')
1765 1767 self.set_hook('complete_command', module_completer, str_key = 'from')
1766 1768 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1767 1769 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1768 1770
1769 1771 # Only configure readline if we truly are using readline. IPython can
1770 1772 # do tab-completion over the network, in GUIs, etc, where readline
1771 1773 # itself may be absent
1772 1774 if self.has_readline:
1773 1775 self.set_readline_completer()
1774 1776
1775 1777 def complete(self, text, line=None, cursor_pos=None):
1776 1778 """Return the completed text and a list of completions.
1777 1779
1778 1780 Parameters
1779 1781 ----------
1780 1782
1781 1783 text : string
1782 1784 A string of text to be completed on. It can be given as empty and
1783 1785 instead a line/position pair are given. In this case, the
1784 1786 completer itself will split the line like readline does.
1785 1787
1786 1788 line : string, optional
1787 1789 The complete line that text is part of.
1788 1790
1789 1791 cursor_pos : int, optional
1790 1792 The position of the cursor on the input line.
1791 1793
1792 1794 Returns
1793 1795 -------
1794 1796 text : string
1795 1797 The actual text that was completed.
1796 1798
1797 1799 matches : list
1798 1800 A sorted list with all possible completions.
1799 1801
1800 1802 The optional arguments allow the completion to take more context into
1801 1803 account, and are part of the low-level completion API.
1802 1804
1803 1805 This is a wrapper around the completion mechanism, similar to what
1804 1806 readline does at the command line when the TAB key is hit. By
1805 1807 exposing it as a method, it can be used by other non-readline
1806 1808 environments (such as GUIs) for text completion.
1807 1809
1808 1810 Simple usage example:
1809 1811
1810 1812 In [1]: x = 'hello'
1811 1813
1812 1814 In [2]: _ip.complete('x.l')
1813 1815 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1814 1816 """
1815 1817
1816 1818 # Inject names into __builtin__ so we can complete on the added names.
1817 1819 with self.builtin_trap:
1818 1820 return self.Completer.complete(text, line, cursor_pos)
1819 1821
1820 1822 def set_custom_completer(self, completer, pos=0):
1821 1823 """Adds a new custom completer function.
1822 1824
1823 1825 The position argument (defaults to 0) is the index in the completers
1824 1826 list where you want the completer to be inserted."""
1825 1827
1826 1828 newcomp = types.MethodType(completer,self.Completer)
1827 1829 self.Completer.matchers.insert(pos,newcomp)
1828 1830
1829 1831 def set_readline_completer(self):
1830 1832 """Reset readline's completer to be our own."""
1831 1833 self.readline.set_completer(self.Completer.rlcomplete)
1832 1834
1833 1835 def set_completer_frame(self, frame=None):
1834 1836 """Set the frame of the completer."""
1835 1837 if frame:
1836 1838 self.Completer.namespace = frame.f_locals
1837 1839 self.Completer.global_namespace = frame.f_globals
1838 1840 else:
1839 1841 self.Completer.namespace = self.user_ns
1840 1842 self.Completer.global_namespace = self.user_global_ns
1841 1843
1842 1844 #-------------------------------------------------------------------------
1843 1845 # Things related to magics
1844 1846 #-------------------------------------------------------------------------
1845 1847
1846 1848 def init_magics(self):
1847 1849 # FIXME: Move the color initialization to the DisplayHook, which
1848 1850 # should be split into a prompt manager and displayhook. We probably
1849 1851 # even need a centralize colors management object.
1850 1852 self.magic_colors(self.colors)
1851 1853 # History was moved to a separate module
1852 1854 from . import history
1853 1855 history.init_ipython(self)
1854 1856
1855 1857 def magic(self, arg_s, next_input=None):
1856 1858 """Call a magic function by name.
1857 1859
1858 1860 Input: a string containing the name of the magic function to call and
1859 1861 any additional arguments to be passed to the magic.
1860 1862
1861 1863 magic('name -opt foo bar') is equivalent to typing at the ipython
1862 1864 prompt:
1863 1865
1864 1866 In[1]: %name -opt foo bar
1865 1867
1866 1868 To call a magic without arguments, simply use magic('name').
1867 1869
1868 1870 This provides a proper Python function to call IPython's magics in any
1869 1871 valid Python code you can type at the interpreter, including loops and
1870 1872 compound statements.
1871 1873 """
1872 1874 # Allow setting the next input - this is used if the user does `a=abs?`.
1873 1875 # We do this first so that magic functions can override it.
1874 1876 if next_input:
1875 1877 self.set_next_input(next_input)
1876 1878
1877 1879 args = arg_s.split(' ',1)
1878 1880 magic_name = args[0]
1879 1881 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1880 1882
1881 1883 try:
1882 1884 magic_args = args[1]
1883 1885 except IndexError:
1884 1886 magic_args = ''
1885 1887 fn = getattr(self,'magic_'+magic_name,None)
1886 1888 if fn is None:
1887 1889 error("Magic function `%s` not found." % magic_name)
1888 1890 else:
1889 1891 magic_args = self.var_expand(magic_args,1)
1890 1892 # Grab local namespace if we need it:
1891 1893 if getattr(fn, "needs_local_scope", False):
1892 1894 self._magic_locals = sys._getframe(1).f_locals
1893 1895 with self.builtin_trap:
1894 1896 result = fn(magic_args)
1895 1897 # Ensure we're not keeping object references around:
1896 1898 self._magic_locals = {}
1897 1899 return result
1898 1900
1899 1901 def define_magic(self, magicname, func):
1900 1902 """Expose own function as magic function for ipython
1901 1903
1902 1904 def foo_impl(self,parameter_s=''):
1903 1905 'My very own magic!. (Use docstrings, IPython reads them).'
1904 1906 print 'Magic function. Passed parameter is between < >:'
1905 1907 print '<%s>' % parameter_s
1906 1908 print 'The self object is:',self
1907 1909
1908 1910 self.define_magic('foo',foo_impl)
1909 1911 """
1910 1912
1911 1913 import new
1912 1914 im = types.MethodType(func,self)
1913 1915 old = getattr(self, "magic_" + magicname, None)
1914 1916 setattr(self, "magic_" + magicname, im)
1915 1917 return old
1916 1918
1917 1919 #-------------------------------------------------------------------------
1918 1920 # Things related to macros
1919 1921 #-------------------------------------------------------------------------
1920 1922
1921 1923 def define_macro(self, name, themacro):
1922 1924 """Define a new macro
1923 1925
1924 1926 Parameters
1925 1927 ----------
1926 1928 name : str
1927 1929 The name of the macro.
1928 1930 themacro : str or Macro
1929 1931 The action to do upon invoking the macro. If a string, a new
1930 1932 Macro object is created by passing the string to it.
1931 1933 """
1932 1934
1933 1935 from IPython.core import macro
1934 1936
1935 1937 if isinstance(themacro, basestring):
1936 1938 themacro = macro.Macro(themacro)
1937 1939 if not isinstance(themacro, macro.Macro):
1938 1940 raise ValueError('A macro must be a string or a Macro instance.')
1939 1941 self.user_ns[name] = themacro
1940 1942
1941 1943 #-------------------------------------------------------------------------
1942 1944 # Things related to the running of system commands
1943 1945 #-------------------------------------------------------------------------
1944 1946
1945 1947 def system_piped(self, cmd):
1946 1948 """Call the given cmd in a subprocess, piping stdout/err
1947 1949
1948 1950 Parameters
1949 1951 ----------
1950 1952 cmd : str
1951 1953 Command to execute (can not end in '&', as background processes are
1952 1954 not supported. Should not be a command that expects input
1953 1955 other than simple text.
1954 1956 """
1955 1957 if cmd.rstrip().endswith('&'):
1956 1958 # this is *far* from a rigorous test
1957 1959 # We do not support backgrounding processes because we either use
1958 1960 # pexpect or pipes to read from. Users can always just call
1959 1961 # os.system() or use ip.system=ip.system_raw
1960 1962 # if they really want a background process.
1961 1963 raise OSError("Background processes not supported.")
1962 1964
1963 1965 # we explicitly do NOT return the subprocess status code, because
1964 1966 # a non-None value would trigger :func:`sys.displayhook` calls.
1965 1967 # Instead, we store the exit_code in user_ns.
1966 1968 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
1967 1969
1968 1970 def system_raw(self, cmd):
1969 1971 """Call the given cmd in a subprocess using os.system
1970 1972
1971 1973 Parameters
1972 1974 ----------
1973 1975 cmd : str
1974 1976 Command to execute.
1975 1977 """
1976 1978 # We explicitly do NOT return the subprocess status code, because
1977 1979 # a non-None value would trigger :func:`sys.displayhook` calls.
1978 1980 # Instead, we store the exit_code in user_ns.
1979 1981 self.user_ns['_exit_code'] = os.system(self.var_expand(cmd, depth=2))
1980 1982
1981 1983 # use piped system by default, because it is better behaved
1982 1984 system = system_piped
1983 1985
1984 1986 def getoutput(self, cmd, split=True):
1985 1987 """Get output (possibly including stderr) from a subprocess.
1986 1988
1987 1989 Parameters
1988 1990 ----------
1989 1991 cmd : str
1990 1992 Command to execute (can not end in '&', as background processes are
1991 1993 not supported.
1992 1994 split : bool, optional
1993 1995
1994 1996 If True, split the output into an IPython SList. Otherwise, an
1995 1997 IPython LSString is returned. These are objects similar to normal
1996 1998 lists and strings, with a few convenience attributes for easier
1997 1999 manipulation of line-based output. You can use '?' on them for
1998 2000 details.
1999 2001 """
2000 2002 if cmd.rstrip().endswith('&'):
2001 2003 # this is *far* from a rigorous test
2002 2004 raise OSError("Background processes not supported.")
2003 2005 out = getoutput(self.var_expand(cmd, depth=2))
2004 2006 if split:
2005 2007 out = SList(out.splitlines())
2006 2008 else:
2007 2009 out = LSString(out)
2008 2010 return out
2009 2011
2010 2012 #-------------------------------------------------------------------------
2011 2013 # Things related to aliases
2012 2014 #-------------------------------------------------------------------------
2013 2015
2014 2016 def init_alias(self):
2015 2017 self.alias_manager = AliasManager(shell=self, config=self.config)
2016 2018 self.ns_table['alias'] = self.alias_manager.alias_table,
2017 2019
2018 2020 #-------------------------------------------------------------------------
2019 2021 # Things related to extensions and plugins
2020 2022 #-------------------------------------------------------------------------
2021 2023
2022 2024 def init_extension_manager(self):
2023 2025 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2024 2026
2025 2027 def init_plugin_manager(self):
2026 2028 self.plugin_manager = PluginManager(config=self.config)
2027 2029
2028 2030 #-------------------------------------------------------------------------
2029 2031 # Things related to payloads
2030 2032 #-------------------------------------------------------------------------
2031 2033
2032 2034 def init_payload(self):
2033 2035 self.payload_manager = PayloadManager(config=self.config)
2034 2036
2035 2037 #-------------------------------------------------------------------------
2036 2038 # Things related to the prefilter
2037 2039 #-------------------------------------------------------------------------
2038 2040
2039 2041 def init_prefilter(self):
2040 2042 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2041 2043 # Ultimately this will be refactored in the new interpreter code, but
2042 2044 # for now, we should expose the main prefilter method (there's legacy
2043 2045 # code out there that may rely on this).
2044 2046 self.prefilter = self.prefilter_manager.prefilter_lines
2045 2047
2046 2048 def auto_rewrite_input(self, cmd):
2047 2049 """Print to the screen the rewritten form of the user's command.
2048 2050
2049 2051 This shows visual feedback by rewriting input lines that cause
2050 2052 automatic calling to kick in, like::
2051 2053
2052 2054 /f x
2053 2055
2054 2056 into::
2055 2057
2056 2058 ------> f(x)
2057 2059
2058 2060 after the user's input prompt. This helps the user understand that the
2059 2061 input line was transformed automatically by IPython.
2060 2062 """
2061 2063 rw = self.displayhook.prompt1.auto_rewrite() + cmd
2062 2064
2063 2065 try:
2064 2066 # plain ascii works better w/ pyreadline, on some machines, so
2065 2067 # we use it and only print uncolored rewrite if we have unicode
2066 2068 rw = str(rw)
2067 2069 print >> io.stdout, rw
2068 2070 except UnicodeEncodeError:
2069 2071 print "------> " + cmd
2070 2072
2071 2073 #-------------------------------------------------------------------------
2072 2074 # Things related to extracting values/expressions from kernel and user_ns
2073 2075 #-------------------------------------------------------------------------
2074 2076
2075 2077 def _simple_error(self):
2076 2078 etype, value = sys.exc_info()[:2]
2077 2079 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2078 2080
2079 2081 def user_variables(self, names):
2080 2082 """Get a list of variable names from the user's namespace.
2081 2083
2082 2084 Parameters
2083 2085 ----------
2084 2086 names : list of strings
2085 2087 A list of names of variables to be read from the user namespace.
2086 2088
2087 2089 Returns
2088 2090 -------
2089 2091 A dict, keyed by the input names and with the repr() of each value.
2090 2092 """
2091 2093 out = {}
2092 2094 user_ns = self.user_ns
2093 2095 for varname in names:
2094 2096 try:
2095 2097 value = repr(user_ns[varname])
2096 2098 except:
2097 2099 value = self._simple_error()
2098 2100 out[varname] = value
2099 2101 return out
2100 2102
2101 2103 def user_expressions(self, expressions):
2102 2104 """Evaluate a dict of expressions in the user's namespace.
2103 2105
2104 2106 Parameters
2105 2107 ----------
2106 2108 expressions : dict
2107 2109 A dict with string keys and string values. The expression values
2108 2110 should be valid Python expressions, each of which will be evaluated
2109 2111 in the user namespace.
2110 2112
2111 2113 Returns
2112 2114 -------
2113 2115 A dict, keyed like the input expressions dict, with the repr() of each
2114 2116 value.
2115 2117 """
2116 2118 out = {}
2117 2119 user_ns = self.user_ns
2118 2120 global_ns = self.user_global_ns
2119 2121 for key, expr in expressions.iteritems():
2120 2122 try:
2121 2123 value = repr(eval(expr, global_ns, user_ns))
2122 2124 except:
2123 2125 value = self._simple_error()
2124 2126 out[key] = value
2125 2127 return out
2126 2128
2127 2129 #-------------------------------------------------------------------------
2128 2130 # Things related to the running of code
2129 2131 #-------------------------------------------------------------------------
2130 2132
2131 2133 def ex(self, cmd):
2132 2134 """Execute a normal python statement in user namespace."""
2133 2135 with self.builtin_trap:
2134 2136 exec cmd in self.user_global_ns, self.user_ns
2135 2137
2136 2138 def ev(self, expr):
2137 2139 """Evaluate python expression expr in user namespace.
2138 2140
2139 2141 Returns the result of evaluation
2140 2142 """
2141 2143 with self.builtin_trap:
2142 2144 return eval(expr, self.user_global_ns, self.user_ns)
2143 2145
2144 2146 def safe_execfile(self, fname, *where, **kw):
2145 2147 """A safe version of the builtin execfile().
2146 2148
2147 2149 This version will never throw an exception, but instead print
2148 2150 helpful error messages to the screen. This only works on pure
2149 2151 Python files with the .py extension.
2150 2152
2151 2153 Parameters
2152 2154 ----------
2153 2155 fname : string
2154 2156 The name of the file to be executed.
2155 2157 where : tuple
2156 2158 One or two namespaces, passed to execfile() as (globals,locals).
2157 2159 If only one is given, it is passed as both.
2158 2160 exit_ignore : bool (False)
2159 2161 If True, then silence SystemExit for non-zero status (it is always
2160 2162 silenced for zero status, as it is so common).
2161 2163 """
2162 2164 kw.setdefault('exit_ignore', False)
2163 2165
2164 2166 fname = os.path.abspath(os.path.expanduser(fname))
2165 2167
2166 2168 # Make sure we can open the file
2167 2169 try:
2168 2170 with open(fname) as thefile:
2169 2171 pass
2170 2172 except:
2171 2173 warn('Could not open file <%s> for safe execution.' % fname)
2172 2174 return
2173 2175
2174 2176 # Find things also in current directory. This is needed to mimic the
2175 2177 # behavior of running a script from the system command line, where
2176 2178 # Python inserts the script's directory into sys.path
2177 2179 dname = os.path.dirname(fname)
2178 2180
2179 2181 if isinstance(fname, unicode):
2180 2182 # execfile uses default encoding instead of filesystem encoding
2181 2183 # so unicode filenames will fail
2182 2184 fname = fname.encode(sys.getfilesystemencoding() or sys.getdefaultencoding())
2183 2185
2184 2186 with prepended_to_syspath(dname):
2185 2187 try:
2186 2188 execfile(fname,*where)
2187 2189 except SystemExit, status:
2188 2190 # If the call was made with 0 or None exit status (sys.exit(0)
2189 2191 # or sys.exit() ), don't bother showing a traceback, as both of
2190 2192 # these are considered normal by the OS:
2191 2193 # > python -c'import sys;sys.exit(0)'; echo $?
2192 2194 # 0
2193 2195 # > python -c'import sys;sys.exit()'; echo $?
2194 2196 # 0
2195 2197 # For other exit status, we show the exception unless
2196 2198 # explicitly silenced, but only in short form.
2197 2199 if status.code not in (0, None) and not kw['exit_ignore']:
2198 2200 self.showtraceback(exception_only=True)
2199 2201 except:
2200 2202 self.showtraceback()
2201 2203
2202 2204 def safe_execfile_ipy(self, fname):
2203 2205 """Like safe_execfile, but for .ipy files with IPython syntax.
2204 2206
2205 2207 Parameters
2206 2208 ----------
2207 2209 fname : str
2208 2210 The name of the file to execute. The filename must have a
2209 2211 .ipy extension.
2210 2212 """
2211 2213 fname = os.path.abspath(os.path.expanduser(fname))
2212 2214
2213 2215 # Make sure we can open the file
2214 2216 try:
2215 2217 with open(fname) as thefile:
2216 2218 pass
2217 2219 except:
2218 2220 warn('Could not open file <%s> for safe execution.' % fname)
2219 2221 return
2220 2222
2221 2223 # Find things also in current directory. This is needed to mimic the
2222 2224 # behavior of running a script from the system command line, where
2223 2225 # Python inserts the script's directory into sys.path
2224 2226 dname = os.path.dirname(fname)
2225 2227
2226 2228 with prepended_to_syspath(dname):
2227 2229 try:
2228 2230 with open(fname) as thefile:
2229 2231 # self.run_cell currently captures all exceptions
2230 2232 # raised in user code. It would be nice if there were
2231 2233 # versions of runlines, execfile that did raise, so
2232 2234 # we could catch the errors.
2233 2235 self.run_cell(thefile.read(), store_history=False)
2234 2236 except:
2235 2237 self.showtraceback()
2236 2238 warn('Unknown failure executing file: <%s>' % fname)
2237 2239
2238 2240 def run_cell(self, raw_cell, store_history=True):
2239 2241 """Run a complete IPython cell.
2240 2242
2241 2243 Parameters
2242 2244 ----------
2243 2245 raw_cell : str
2244 2246 The code (including IPython code such as %magic functions) to run.
2245 2247 store_history : bool
2246 2248 If True, the raw and translated cell will be stored in IPython's
2247 2249 history. For user code calling back into IPython's machinery, this
2248 2250 should be set to False.
2249 2251 """
2250 2252 if (not raw_cell) or raw_cell.isspace():
2251 2253 return
2252 2254
2253 2255 for line in raw_cell.splitlines():
2254 2256 self.input_splitter.push(line)
2255 2257 cell = self.input_splitter.source_reset()
2256 2258
2257 2259 with self.builtin_trap:
2258 2260 prefilter_failed = False
2259 2261 if len(cell.splitlines()) == 1:
2260 2262 try:
2261 2263 # use prefilter_lines to handle trailing newlines
2262 2264 # restore trailing newline for ast.parse
2263 2265 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2264 2266 except AliasError as e:
2265 2267 error(e)
2266 2268 prefilter_failed=True
2267 2269 except Exception:
2268 2270 # don't allow prefilter errors to crash IPython
2269 2271 self.showtraceback()
2270 2272 prefilter_failed = True
2271 2273
2272 2274 # Store raw and processed history
2273 2275 if store_history:
2274 2276 self.history_manager.store_inputs(self.execution_count,
2275 2277 cell, raw_cell)
2276 2278
2277 2279 self.logger.log(cell, raw_cell)
2278 2280
2279 2281 if not prefilter_failed:
2280 2282 # don't run if prefilter failed
2281 2283 cell_name = self.compile.cache(cell, self.execution_count)
2282 2284
2283 2285 with self.display_trap:
2284 2286 try:
2285 2287 code_ast = ast.parse(cell, filename=cell_name)
2286 2288 except IndentationError:
2287 2289 self.showindentationerror()
2288 2290 self.execution_count += 1
2289 2291 return None
2290 2292 except (OverflowError, SyntaxError, ValueError, TypeError,
2291 2293 MemoryError):
2292 2294 self.showsyntaxerror()
2293 2295 self.execution_count += 1
2294 2296 return None
2295 2297
2296 2298 self.run_ast_nodes(code_ast.body, cell_name,
2297 2299 interactivity="last_expr")
2298 2300
2299 2301 # Execute any registered post-execution functions.
2300 2302 for func, status in self._post_execute.iteritems():
2301 2303 if not status:
2302 2304 continue
2303 2305 try:
2304 2306 func()
2305 2307 except:
2306 2308 self.showtraceback()
2307 2309 # Deactivate failing function
2308 2310 self._post_execute[func] = False
2309 2311
2310 2312 if store_history:
2311 2313 # Write output to the database. Does nothing unless
2312 2314 # history output logging is enabled.
2313 2315 self.history_manager.store_output(self.execution_count)
2314 2316 # Each cell is a *single* input, regardless of how many lines it has
2315 2317 self.execution_count += 1
2316 2318
2317 2319 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2318 2320 """Run a sequence of AST nodes. The execution mode depends on the
2319 2321 interactivity parameter.
2320 2322
2321 2323 Parameters
2322 2324 ----------
2323 2325 nodelist : list
2324 2326 A sequence of AST nodes to run.
2325 2327 cell_name : str
2326 2328 Will be passed to the compiler as the filename of the cell. Typically
2327 2329 the value returned by ip.compile.cache(cell).
2328 2330 interactivity : str
2329 2331 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2330 2332 run interactively (displaying output from expressions). 'last_expr'
2331 2333 will run the last node interactively only if it is an expression (i.e.
2332 2334 expressions in loops or other blocks are not displayed. Other values
2333 2335 for this parameter will raise a ValueError.
2334 2336 """
2335 2337 if not nodelist:
2336 2338 return
2337 2339
2338 2340 if interactivity == 'last_expr':
2339 2341 if isinstance(nodelist[-1], ast.Expr):
2340 2342 interactivity = "last"
2341 2343 else:
2342 2344 interactivity = "none"
2343 2345
2344 2346 if interactivity == 'none':
2345 2347 to_run_exec, to_run_interactive = nodelist, []
2346 2348 elif interactivity == 'last':
2347 2349 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2348 2350 elif interactivity == 'all':
2349 2351 to_run_exec, to_run_interactive = [], nodelist
2350 2352 else:
2351 2353 raise ValueError("Interactivity was %r" % interactivity)
2352 2354
2353 2355 exec_count = self.execution_count
2354 2356
2355 2357 for i, node in enumerate(to_run_exec):
2356 2358 mod = ast.Module([node])
2357 2359 code = self.compile(mod, cell_name, "exec")
2358 2360 if self.run_code(code):
2359 2361 return True
2360 2362
2361 2363 for i, node in enumerate(to_run_interactive):
2362 2364 mod = ast.Interactive([node])
2363 2365 code = self.compile(mod, cell_name, "single")
2364 2366 if self.run_code(code):
2365 2367 return True
2366 2368
2367 2369 return False
2368 2370
2369 2371 def run_code(self, code_obj):
2370 2372 """Execute a code object.
2371 2373
2372 2374 When an exception occurs, self.showtraceback() is called to display a
2373 2375 traceback.
2374 2376
2375 2377 Parameters
2376 2378 ----------
2377 2379 code_obj : code object
2378 2380 A compiled code object, to be executed
2379 2381 post_execute : bool [default: True]
2380 2382 whether to call post_execute hooks after this particular execution.
2381 2383
2382 2384 Returns
2383 2385 -------
2384 2386 False : successful execution.
2385 2387 True : an error occurred.
2386 2388 """
2387 2389
2388 2390 # Set our own excepthook in case the user code tries to call it
2389 2391 # directly, so that the IPython crash handler doesn't get triggered
2390 2392 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2391 2393
2392 2394 # we save the original sys.excepthook in the instance, in case config
2393 2395 # code (such as magics) needs access to it.
2394 2396 self.sys_excepthook = old_excepthook
2395 2397 outflag = 1 # happens in more places, so it's easier as default
2396 2398 try:
2397 2399 try:
2398 2400 self.hooks.pre_run_code_hook()
2399 2401 #rprint('Running code', repr(code_obj)) # dbg
2400 2402 exec code_obj in self.user_global_ns, self.user_ns
2401 2403 finally:
2402 2404 # Reset our crash handler in place
2403 2405 sys.excepthook = old_excepthook
2404 2406 except SystemExit:
2405 2407 self.showtraceback(exception_only=True)
2406 2408 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2407 2409 except self.custom_exceptions:
2408 2410 etype,value,tb = sys.exc_info()
2409 2411 self.CustomTB(etype,value,tb)
2410 2412 except:
2411 2413 self.showtraceback()
2412 2414 else:
2413 2415 outflag = 0
2414 2416 if softspace(sys.stdout, 0):
2415 2417 print
2416 2418
2417 2419 return outflag
2418 2420
2419 2421 # For backwards compatibility
2420 2422 runcode = run_code
2421 2423
2422 2424 #-------------------------------------------------------------------------
2423 2425 # Things related to GUI support and pylab
2424 2426 #-------------------------------------------------------------------------
2425 2427
2426 2428 def enable_pylab(self, gui=None, import_all=True):
2427 2429 raise NotImplementedError('Implement enable_pylab in a subclass')
2428 2430
2429 2431 #-------------------------------------------------------------------------
2430 2432 # Utilities
2431 2433 #-------------------------------------------------------------------------
2432 2434
2433 2435 def var_expand(self,cmd,depth=0):
2434 2436 """Expand python variables in a string.
2435 2437
2436 2438 The depth argument indicates how many frames above the caller should
2437 2439 be walked to look for the local namespace where to expand variables.
2438 2440
2439 2441 The global namespace for expansion is always the user's interactive
2440 2442 namespace.
2441 2443 """
2442 2444 res = ItplNS(cmd, self.user_ns, # globals
2443 2445 # Skip our own frame in searching for locals:
2444 2446 sys._getframe(depth+1).f_locals # locals
2445 2447 )
2446 2448 return str(res).decode(res.codec)
2447 2449
2448 2450 def mktempfile(self, data=None, prefix='ipython_edit_'):
2449 2451 """Make a new tempfile and return its filename.
2450 2452
2451 2453 This makes a call to tempfile.mktemp, but it registers the created
2452 2454 filename internally so ipython cleans it up at exit time.
2453 2455
2454 2456 Optional inputs:
2455 2457
2456 2458 - data(None): if data is given, it gets written out to the temp file
2457 2459 immediately, and the file is closed again."""
2458 2460
2459 2461 filename = tempfile.mktemp('.py', prefix)
2460 2462 self.tempfiles.append(filename)
2461 2463
2462 2464 if data:
2463 2465 tmp_file = open(filename,'w')
2464 2466 tmp_file.write(data)
2465 2467 tmp_file.close()
2466 2468 return filename
2467 2469
2468 2470 # TODO: This should be removed when Term is refactored.
2469 2471 def write(self,data):
2470 2472 """Write a string to the default output"""
2471 2473 io.stdout.write(data)
2472 2474
2473 2475 # TODO: This should be removed when Term is refactored.
2474 2476 def write_err(self,data):
2475 2477 """Write a string to the default error output"""
2476 2478 io.stderr.write(data)
2477 2479
2478 2480 def ask_yes_no(self,prompt,default=True):
2479 2481 if self.quiet:
2480 2482 return True
2481 2483 return ask_yes_no(prompt,default)
2482 2484
2483 2485 def show_usage(self):
2484 2486 """Show a usage message"""
2485 2487 page.page(IPython.core.usage.interactive_usage)
2486 2488
2487 2489 def find_user_code(self, target, raw=True):
2488 2490 """Get a code string from history, file, or a string or macro.
2489 2491
2490 2492 This is mainly used by magic functions.
2491 2493
2492 2494 Parameters
2493 2495 ----------
2494 2496 target : str
2495 2497 A string specifying code to retrieve. This will be tried respectively
2496 2498 as: ranges of input history (see %history for syntax), a filename, or
2497 2499 an expression evaluating to a string or Macro in the user namespace.
2498 2500 raw : bool
2499 2501 If true (default), retrieve raw history. Has no effect on the other
2500 2502 retrieval mechanisms.
2501 2503
2502 2504 Returns
2503 2505 -------
2504 2506 A string of code.
2505 2507
2506 2508 ValueError is raised if nothing is found, and TypeError if it evaluates
2507 2509 to an object of another type. In each case, .args[0] is a printable
2508 2510 message.
2509 2511 """
2510 2512 code = self.extract_input_lines(target, raw=raw) # Grab history
2511 2513 if code:
2512 2514 return code
2513 2515 if os.path.isfile(target): # Read file
2514 2516 return open(target, "r").read()
2515 2517
2516 2518 try: # User namespace
2517 2519 codeobj = eval(target, self.user_ns)
2518 2520 except Exception:
2519 2521 raise ValueError(("'%s' was not found in history, as a file, nor in"
2520 2522 " the user namespace.") % target)
2521 2523 if isinstance(codeobj, basestring):
2522 2524 return codeobj
2523 2525 elif isinstance(codeobj, Macro):
2524 2526 return codeobj.value
2525 2527
2526 2528 raise TypeError("%s is neither a string nor a macro." % target,
2527 2529 codeobj)
2528 2530
2529 2531 #-------------------------------------------------------------------------
2530 2532 # Things related to IPython exiting
2531 2533 #-------------------------------------------------------------------------
2532 2534 def atexit_operations(self):
2533 2535 """This will be executed at the time of exit.
2534 2536
2535 2537 Cleanup operations and saving of persistent data that is done
2536 2538 unconditionally by IPython should be performed here.
2537 2539
2538 2540 For things that may depend on startup flags or platform specifics (such
2539 2541 as having readline or not), register a separate atexit function in the
2540 2542 code that has the appropriate information, rather than trying to
2541 2543 clutter
2542 2544 """
2543 2545 # Cleanup all tempfiles left around
2544 2546 for tfile in self.tempfiles:
2545 2547 try:
2546 2548 os.unlink(tfile)
2547 2549 except OSError:
2548 2550 pass
2549 2551
2550 2552 # Close the history session (this stores the end time and line count)
2551 2553 self.history_manager.end_session()
2552 2554
2553 2555 # Clear all user namespaces to release all references cleanly.
2554 2556 self.reset(new_session=False)
2555 2557
2556 2558 # Run user hooks
2557 2559 self.hooks.shutdown_hook()
2558 2560
2559 2561 def cleanup(self):
2560 2562 self.restore_sys_module_state()
2561 2563
2562 2564
2563 2565 class InteractiveShellABC(object):
2564 2566 """An abstract base class for InteractiveShell."""
2565 2567 __metaclass__ = abc.ABCMeta
2566 2568
2567 2569 InteractiveShellABC.register(InteractiveShell)
@@ -1,183 +1,194 b''
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.core import completer
17 17 from IPython.external.decorators import knownfailureif
18 18 from IPython.utils.tempdir import TemporaryDirectory
19 19
20 20 #-----------------------------------------------------------------------------
21 21 # Test functions
22 22 #-----------------------------------------------------------------------------
23 23 def test_protect_filename():
24 24 pairs = [ ('abc','abc'),
25 25 (' abc',r'\ abc'),
26 26 ('a bc',r'a\ bc'),
27 27 ('a bc',r'a\ \ bc'),
28 28 (' bc',r'\ \ bc'),
29 29 ]
30 30 # On posix, we also protect parens and other special characters
31 31 if sys.platform != 'win32':
32 32 pairs.extend( [('a(bc',r'a\(bc'),
33 33 ('a)bc',r'a\)bc'),
34 34 ('a( )bc',r'a\(\ \)bc'),
35 35 ('a[1]bc', r'a\[1\]bc'),
36 36 ('a{1}bc', r'a\{1\}bc'),
37 37 ('a#bc', r'a\#bc'),
38 38 ('a?bc', r'a\?bc'),
39 39 ('a=bc', r'a\=bc'),
40 40 ('a\\bc', r'a\\bc'),
41 41 ('a|bc', r'a\|bc'),
42 42 ('a;bc', r'a\;bc'),
43 43 ('a:bc', r'a\:bc'),
44 44 ("a'bc", r"a\'bc"),
45 45 ('a*bc', r'a\*bc'),
46 46 ('a"bc', r'a\"bc'),
47 47 ('a^bc', r'a\^bc'),
48 48 ('a&bc', r'a\&bc'),
49 49 ] )
50 50 # run the actual tests
51 51 for s1, s2 in pairs:
52 52 s1p = completer.protect_filename(s1)
53 53 nt.assert_equals(s1p, s2)
54 54
55 55
56 56 def check_line_split(splitter, test_specs):
57 57 for part1, part2, split in test_specs:
58 58 cursor_pos = len(part1)
59 59 line = part1+part2
60 60 out = splitter.split_line(line, cursor_pos)
61 61 nt.assert_equal(out, split)
62 62
63 63
64 64 def test_line_split():
65 65 """Basice line splitter test with default specs."""
66 66 sp = completer.CompletionSplitter()
67 67 # The format of the test specs is: part1, part2, expected answer. Parts 1
68 68 # and 2 are joined into the 'line' sent to the splitter, as if the cursor
69 69 # was at the end of part1. So an empty part2 represents someone hitting
70 70 # tab at the end of the line, the most common case.
71 71 t = [('run some/scrip', '', 'some/scrip'),
72 72 ('run scripts/er', 'ror.py foo', 'scripts/er'),
73 73 ('echo $HOM', '', 'HOM'),
74 74 ('print sys.pa', '', 'sys.pa'),
75 75 ('print(sys.pa', '', 'sys.pa'),
76 76 ("execfile('scripts/er", '', 'scripts/er'),
77 77 ('a[x.', '', 'x.'),
78 78 ('a[x.', 'y', 'x.'),
79 79 ('cd "some_file/', '', 'some_file/'),
80 80 ]
81 81 check_line_split(sp, t)
82 82 # Ensure splitting works OK with unicode by re-running the tests with
83 83 # all inputs turned into unicode
84 84 check_line_split(sp, [ map(unicode, p) for p in t] )
85 85
86 86
87 87 def test_unicode_completions():
88 88 ip = get_ipython()
89 89 # Some strings that trigger different types of completion. Check them both
90 90 # in str and unicode forms
91 91 s = ['ru', '%ru', 'cd /', 'floa', 'float(x)/']
92 92 for t in s + map(unicode, s):
93 93 # We don't need to check exact completion values (they may change
94 94 # depending on the state of the namespace, but at least no exceptions
95 95 # should be thrown and the return value should be a pair of text, list
96 96 # values.
97 97 text, matches = ip.complete(t)
98 98 nt.assert_true(isinstance(text, basestring))
99 99 nt.assert_true(isinstance(matches, list))
100 100
101 101
102 102 class CompletionSplitterTestCase(unittest.TestCase):
103 103 def setUp(self):
104 104 self.sp = completer.CompletionSplitter()
105 105
106 106 def test_delim_setting(self):
107 107 self.sp.set_delims(' ')
108 108 nt.assert_equal(self.sp.get_delims(), ' ')
109 109 nt.assert_equal(self.sp._delim_expr, '[\ ]')
110 110
111 111 def test_spaces(self):
112 112 """Test with only spaces as split chars."""
113 113 self.sp.delims = ' '
114 114 t = [('foo', '', 'foo'),
115 115 ('run foo', '', 'foo'),
116 116 ('run foo', 'bar', 'foo'),
117 117 ]
118 118 check_line_split(self.sp, t)
119 119
120 120
121 121 def test_has_open_quotes1():
122 122 for s in ["'", "'''", "'hi' '"]:
123 123 nt.assert_equal(completer.has_open_quotes(s), "'")
124 124
125 125
126 126 def test_has_open_quotes2():
127 127 for s in ['"', '"""', '"hi" "']:
128 128 nt.assert_equal(completer.has_open_quotes(s), '"')
129 129
130 130
131 131 def test_has_open_quotes3():
132 132 for s in ["''", "''' '''", "'hi' 'ipython'"]:
133 133 nt.assert_false(completer.has_open_quotes(s))
134 134
135 135
136 136 def test_has_open_quotes4():
137 137 for s in ['""', '""" """', '"hi" "ipython"']:
138 138 nt.assert_false(completer.has_open_quotes(s))
139 139
140 140 @knownfailureif(sys.platform == 'win32', "abspath completions fail on Windows")
141 141 def test_abspath_file_completions():
142 142 ip = get_ipython()
143 143 with TemporaryDirectory() as tmpdir:
144 144 prefix = os.path.join(tmpdir, 'foo')
145 145 suffixes = map(str, [1,2])
146 146 names = [prefix+s for s in suffixes]
147 147 for n in names:
148 148 open(n, 'w').close()
149 149
150 150 # Check simple completion
151 151 c = ip.complete(prefix)[1]
152 152 nt.assert_equal(c, names)
153 153
154 154 # Now check with a function call
155 155 cmd = 'a = f("%s' % prefix
156 156 c = ip.complete(prefix, cmd)[1]
157 157 comp = [prefix+s for s in suffixes]
158 158 nt.assert_equal(c, comp)
159 159
160 160 def test_local_file_completions():
161 161 ip = get_ipython()
162 162 cwd = os.getcwdu()
163 163 try:
164 164 with TemporaryDirectory() as tmpdir:
165 165 os.chdir(tmpdir)
166 166 prefix = './foo'
167 167 suffixes = map(str, [1,2])
168 168 names = [prefix+s for s in suffixes]
169 169 for n in names:
170 170 open(n, 'w').close()
171 171
172 172 # Check simple completion
173 173 c = ip.complete(prefix)[1]
174 174 nt.assert_equal(c, names)
175 175
176 176 # Now check with a function call
177 177 cmd = 'a = f("%s' % prefix
178 178 c = ip.complete(prefix, cmd)[1]
179 179 comp = [prefix+s for s in suffixes]
180 180 nt.assert_equal(c, comp)
181 181 finally:
182 182 # prevent failures from making chdir stick
183 183 os.chdir(cwd)
184
185 def test_greedy_completions():
186 ip = get_ipython()
187 ip.Completer.greedy = False
188 ip.ex('a=range(5)')
189 _,c = ip.complete('.',line='a[0].')
190 nt.assert_false('a[0].real' in c, "Shouldn't have completed on a[0]: %s"%c)
191 ip.Completer.greedy = True
192 _,c = ip.complete('.',line='a[0].')
193 nt.assert_true('a[0].real' in c, "Should have completed on a[0]: %s"%c)
194
@@ -1,383 +1,385 b''
1 1 #!/usr/bin/env python
2 2 # encoding: utf-8
3 3 """
4 4 The :class:`~IPython.core.application.Application` object for the command
5 5 line :command:`ipython` program.
6 6
7 7 Authors
8 8 -------
9 9
10 10 * Brian Granger
11 11 * Fernando Perez
12 12 * Min Ragan-Kelley
13 13 """
14 14
15 15 #-----------------------------------------------------------------------------
16 16 # Copyright (C) 2008-2010 The IPython Development Team
17 17 #
18 18 # Distributed under the terms of the BSD License. The full license is in
19 19 # the file COPYING, distributed as part of this software.
20 20 #-----------------------------------------------------------------------------
21 21
22 22 #-----------------------------------------------------------------------------
23 23 # Imports
24 24 #-----------------------------------------------------------------------------
25 25
26 26 from __future__ import absolute_import
27 27
28 28 import logging
29 29 import os
30 30 import sys
31 31
32 32 from IPython.config.loader import (
33 33 Config, PyFileConfigLoader
34 34 )
35 35 from IPython.config.application import boolean_flag
36 36 from IPython.core import release
37 37 from IPython.core import usage
38 from IPython.core.completer import Completer
38 39 from IPython.core.crashhandler import CrashHandler
39 40 from IPython.core.formatters import PlainTextFormatter
40 41 from IPython.core.application import (
41 42 ProfileDir, BaseIPythonApplication, base_flags, base_aliases
42 43 )
43 44 from IPython.core.shellapp import (
44 45 InteractiveShellApp, shell_flags, shell_aliases
45 46 )
46 47 from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
47 48 from IPython.lib import inputhook
48 49 from IPython.utils import warn
49 50 from IPython.utils.path import get_ipython_dir, check_for_old_config
50 51 from IPython.utils.traitlets import (
51 52 Bool, List, Dict, CaselessStrEnum
52 53 )
53 54
54 55 #-----------------------------------------------------------------------------
55 56 # Globals, utilities and helpers
56 57 #-----------------------------------------------------------------------------
57 58
58 59 #: The default config file name for this application.
59 60 default_config_file_name = u'ipython_config.py'
60 61
61 62 _examples = """
62 63 ipython --pylab # start in pylab mode
63 64 ipython --pylab=qt # start in pylab mode with the qt4 backend
64 65 ipython --log-level=DEBUG # set logging to DEBUG
65 66 ipython --profile=foo # start with profile foo
66 67
67 68 ipython qtconsole # start the qtconsole GUI application
68 69 ipython qtconsole -h # show the help string for the qtconsole subcmd
69 70
70 71 ipython profile create foo # create profile foo w/ default config files
71 72 ipython profile -h # show the help string for the profile subcmd
72 73 """
73 74
74 75 #-----------------------------------------------------------------------------
75 76 # Crash handler for this application
76 77 #-----------------------------------------------------------------------------
77 78
78 79 class IPAppCrashHandler(CrashHandler):
79 80 """sys.excepthook for IPython itself, leaves a detailed report on disk."""
80 81
81 82 def __init__(self, app):
82 83 contact_name = release.authors['Fernando'][0]
83 84 contact_email = release.authors['Fernando'][1]
84 85 bug_tracker = 'http://github.com/ipython/ipython/issues'
85 86 super(IPAppCrashHandler,self).__init__(
86 87 app, contact_name, contact_email, bug_tracker
87 88 )
88 89
89 90 def make_report(self,traceback):
90 91 """Return a string containing a crash report."""
91 92
92 93 sec_sep = self.section_sep
93 94 # Start with parent report
94 95 report = [super(IPAppCrashHandler, self).make_report(traceback)]
95 96 # Add interactive-specific info we may have
96 97 rpt_add = report.append
97 98 try:
98 99 rpt_add(sec_sep+"History of session input:")
99 100 for line in self.app.shell.user_ns['_ih']:
100 101 rpt_add(line)
101 102 rpt_add('\n*** Last line of input (may not be in above history):\n')
102 103 rpt_add(self.app.shell._last_input_line+'\n')
103 104 except:
104 105 pass
105 106
106 107 return ''.join(report)
107 108
108 109 #-----------------------------------------------------------------------------
109 110 # Aliases and Flags
110 111 #-----------------------------------------------------------------------------
111 112 flags = dict(base_flags)
112 113 flags.update(shell_flags)
113 114 addflag = lambda *args: flags.update(boolean_flag(*args))
114 115 addflag('autoedit-syntax', 'TerminalInteractiveShell.autoedit_syntax',
115 116 'Turn on auto editing of files with syntax errors.',
116 117 'Turn off auto editing of files with syntax errors.'
117 118 )
118 119 addflag('banner', 'TerminalIPythonApp.display_banner',
119 120 "Display a banner upon starting IPython.",
120 121 "Don't display a banner upon starting IPython."
121 122 )
122 123 addflag('confirm-exit', 'TerminalInteractiveShell.confirm_exit',
123 124 """Set to confirm when you try to exit IPython with an EOF (Control-D
124 125 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
125 126 you can force a direct exit without any confirmation.""",
126 127 "Don't prompt the user when exiting."
127 128 )
128 129 addflag('term-title', 'TerminalInteractiveShell.term_title',
129 130 "Enable auto setting the terminal title.",
130 131 "Disable auto setting the terminal title."
131 132 )
132 133 classic_config = Config()
133 134 classic_config.InteractiveShell.cache_size = 0
134 135 classic_config.PlainTextFormatter.pprint = False
135 136 classic_config.InteractiveShell.prompt_in1 = '>>> '
136 137 classic_config.InteractiveShell.prompt_in2 = '... '
137 138 classic_config.InteractiveShell.prompt_out = ''
138 139 classic_config.InteractiveShell.separate_in = ''
139 140 classic_config.InteractiveShell.separate_out = ''
140 141 classic_config.InteractiveShell.separate_out2 = ''
141 142 classic_config.InteractiveShell.colors = 'NoColor'
142 143 classic_config.InteractiveShell.xmode = 'Plain'
143 144
144 145 flags['classic']=(
145 146 classic_config,
146 147 "Gives IPython a similar feel to the classic Python prompt."
147 148 )
148 149 # # log doesn't make so much sense this way anymore
149 150 # paa('--log','-l',
150 151 # action='store_true', dest='InteractiveShell.logstart',
151 152 # help="Start logging to the default log file (./ipython_log.py).")
152 153 #
153 154 # # quick is harder to implement
154 155 flags['quick']=(
155 156 {'TerminalIPythonApp' : {'quick' : True}},
156 157 "Enable quick startup with no config files."
157 158 )
158 159
159 160 flags['i'] = (
160 161 {'TerminalIPythonApp' : {'force_interact' : True}},
161 162 """If running code from the command line, become interactive afterwards.
162 163 Note: can also be given simply as '-i.'"""
163 164 )
164 165 flags['pylab'] = (
165 166 {'TerminalIPythonApp' : {'pylab' : 'auto'}},
166 167 """Pre-load matplotlib and numpy for interactive use with
167 168 the default matplotlib backend."""
168 169 )
169 170
170 171 aliases = dict(base_aliases)
171 172 aliases.update(shell_aliases)
172 173
173 174 # it's possible we don't want short aliases for *all* of these:
174 175 aliases.update(dict(
175 176 gui='TerminalIPythonApp.gui',
176 177 pylab='TerminalIPythonApp.pylab',
177 178 ))
178 179
179 180 #-----------------------------------------------------------------------------
180 181 # Main classes and functions
181 182 #-----------------------------------------------------------------------------
182 183
183 184 class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):
184 185 name = u'ipython'
185 186 description = usage.cl_usage
186 187 default_config_file_name = default_config_file_name
187 188 crash_handler_class = IPAppCrashHandler
188 189 examples = _examples
189 190
190 191 flags = Dict(flags)
191 192 aliases = Dict(aliases)
192 193 classes = List()
193 194 def _classes_default(self):
194 195 """This has to be in a method, for TerminalIPythonApp to be available."""
195 196 return [
196 197 InteractiveShellApp, # ShellApp comes before TerminalApp, because
197 198 self.__class__, # it will also affect subclasses (e.g. QtConsole)
198 199 TerminalInteractiveShell,
199 200 ProfileDir,
200 201 PlainTextFormatter,
202 Completer,
201 203 ]
202 204
203 205 subcommands = Dict(dict(
204 206 qtconsole=('IPython.frontend.qt.console.qtconsoleapp.IPythonQtConsoleApp',
205 207 """Launch the IPython Qt Console."""
206 208 ),
207 209 profile = ("IPython.core.profileapp.ProfileApp",
208 210 "Create and manage IPython profiles.")
209 211 ))
210 212
211 213 # *do* autocreate requested profile, but don't create the config file.
212 214 auto_create=Bool(True)
213 215 # configurables
214 216 ignore_old_config=Bool(False, config=True,
215 217 help="Suppress warning messages about legacy config files"
216 218 )
217 219 quick = Bool(False, config=True,
218 220 help="""Start IPython quickly by skipping the loading of config files."""
219 221 )
220 222 def _quick_changed(self, name, old, new):
221 223 if new:
222 224 self.load_config_file = lambda *a, **kw: None
223 225 self.ignore_old_config=True
224 226
225 227 gui = CaselessStrEnum(('qt','wx','gtk'), config=True,
226 228 help="Enable GUI event loop integration ('qt', 'wx', 'gtk')."
227 229 )
228 230 pylab = CaselessStrEnum(['tk', 'qt', 'wx', 'gtk', 'osx', 'auto'],
229 231 config=True,
230 232 help="""Pre-load matplotlib and numpy for interactive use,
231 233 selecting a particular matplotlib backend and loop integration.
232 234 """
233 235 )
234 236 display_banner = Bool(True, config=True,
235 237 help="Whether to display a banner upon starting IPython."
236 238 )
237 239
238 240 # if there is code of files to run from the cmd line, don't interact
239 241 # unless the --i flag (App.force_interact) is true.
240 242 force_interact = Bool(False, config=True,
241 243 help="""If a command or file is given via the command-line,
242 244 e.g. 'ipython foo.py"""
243 245 )
244 246 def _force_interact_changed(self, name, old, new):
245 247 if new:
246 248 self.interact = True
247 249
248 250 def _file_to_run_changed(self, name, old, new):
249 251 if new and not self.force_interact:
250 252 self.interact = False
251 253 _code_to_run_changed = _file_to_run_changed
252 254
253 255 # internal, not-configurable
254 256 interact=Bool(True)
255 257
256 258
257 259 def parse_command_line(self, argv=None):
258 260 """override to allow old '-pylab' flag with deprecation warning"""
259 261
260 262 argv = sys.argv[1:] if argv is None else argv
261 263
262 264 if '-pylab' in argv:
263 265 # deprecated `-pylab` given,
264 266 # warn and transform into current syntax
265 267 argv = argv[:] # copy, don't clobber
266 268 idx = argv.index('-pylab')
267 269 warn.warn("`-pylab` flag has been deprecated.\n"
268 270 " Use `--pylab` instead, or `--pylab=foo` to specify a backend.")
269 271 sub = '--pylab'
270 272 if len(argv) > idx+1:
271 273 # check for gui arg, as in '-pylab qt'
272 274 gui = argv[idx+1]
273 275 if gui in ('wx', 'qt', 'qt4', 'gtk', 'auto'):
274 276 sub = '--pylab='+gui
275 277 argv.pop(idx+1)
276 278 argv[idx] = sub
277 279
278 280 return super(TerminalIPythonApp, self).parse_command_line(argv)
279 281
280 282 def initialize(self, argv=None):
281 283 """Do actions after construct, but before starting the app."""
282 284 super(TerminalIPythonApp, self).initialize(argv)
283 285 if self.subapp is not None:
284 286 # don't bother initializing further, starting subapp
285 287 return
286 288 if not self.ignore_old_config:
287 289 check_for_old_config(self.ipython_dir)
288 290 # print self.extra_args
289 291 if self.extra_args:
290 292 self.file_to_run = self.extra_args[0]
291 293 # create the shell
292 294 self.init_shell()
293 295 # and draw the banner
294 296 self.init_banner()
295 297 # Now a variety of things that happen after the banner is printed.
296 298 self.init_gui_pylab()
297 299 self.init_extensions()
298 300 self.init_code()
299 301
300 302 def init_shell(self):
301 303 """initialize the InteractiveShell instance"""
302 304 # I am a little hesitant to put these into InteractiveShell itself.
303 305 # But that might be the place for them
304 306 sys.path.insert(0, '')
305 307
306 308 # Create an InteractiveShell instance.
307 309 # shell.display_banner should always be False for the terminal
308 310 # based app, because we call shell.show_banner() by hand below
309 311 # so the banner shows *before* all extension loading stuff.
310 312 self.shell = TerminalInteractiveShell.instance(config=self.config,
311 313 display_banner=False, profile_dir=self.profile_dir,
312 314 ipython_dir=self.ipython_dir)
313 315
314 316 def init_banner(self):
315 317 """optionally display the banner"""
316 318 if self.display_banner and self.interact:
317 319 self.shell.show_banner()
318 320 # Make sure there is a space below the banner.
319 321 if self.log_level <= logging.INFO: print
320 322
321 323
322 324 def init_gui_pylab(self):
323 325 """Enable GUI event loop integration, taking pylab into account."""
324 326 gui = self.gui
325 327
326 328 # Using `pylab` will also require gui activation, though which toolkit
327 329 # to use may be chosen automatically based on mpl configuration.
328 330 if self.pylab:
329 331 activate = self.shell.enable_pylab
330 332 if self.pylab == 'auto':
331 333 gui = None
332 334 else:
333 335 gui = self.pylab
334 336 else:
335 337 # Enable only GUI integration, no pylab
336 338 activate = inputhook.enable_gui
337 339
338 340 if gui or self.pylab:
339 341 try:
340 342 self.log.info("Enabling GUI event loop integration, "
341 343 "toolkit=%s, pylab=%s" % (gui, self.pylab) )
342 344 activate(gui)
343 345 except:
344 346 self.log.warn("Error in enabling GUI event loop integration:")
345 347 self.shell.showtraceback()
346 348
347 349 def start(self):
348 350 if self.subapp is not None:
349 351 return self.subapp.start()
350 352 # perform any prexec steps:
351 353 if self.interact:
352 354 self.log.debug("Starting IPython's mainloop...")
353 355 self.shell.mainloop()
354 356 else:
355 357 self.log.debug("IPython not interactive...")
356 358
357 359
358 360 def load_default_config(ipython_dir=None):
359 361 """Load the default config file from the default ipython_dir.
360 362
361 363 This is useful for embedded shells.
362 364 """
363 365 if ipython_dir is None:
364 366 ipython_dir = get_ipython_dir()
365 367 profile_dir = os.path.join(ipython_dir, 'profile_default')
366 368 cl = PyFileConfigLoader(default_config_file_name, profile_dir)
367 369 try:
368 370 config = cl.load_config()
369 371 except IOError:
370 372 # no config found
371 373 config = Config()
372 374 return config
373 375
374 376
375 377 def launch_new_instance():
376 378 """Create and run a full blown IPython instance"""
377 379 app = TerminalIPythonApp.instance()
378 380 app.initialize()
379 381 app.start()
380 382
381 383
382 384 if __name__ == '__main__':
383 385 launch_new_instance()
General Comments 0
You need to be logged in to leave comments. Login now