##// END OF EJS Templates
Parse user code to AST using compiler flags....
Thomas Kluyver -
Show More
@@ -1,117 +1,128 b''
1 1 """Compiler tools with improved interactive support.
2 2
3 3 Provides compilation machinery similar to codeop, but with caching support so
4 4 we can provide interactive tracebacks.
5 5
6 6 Authors
7 7 -------
8 8 * Robert Kern
9 9 * Fernando Perez
10 10 * Thomas Kluyver
11 11 """
12 12
13 13 # Note: though it might be more natural to name this module 'compiler', that
14 14 # name is in the stdlib and name collisions with the stdlib tend to produce
15 15 # weird problems (often with third-party tools).
16 16
17 17 #-----------------------------------------------------------------------------
18 18 # Copyright (C) 2010 The IPython Development Team.
19 19 #
20 20 # Distributed under the terms of the BSD License.
21 21 #
22 22 # The full license is in the file COPYING.txt, distributed with this software.
23 23 #-----------------------------------------------------------------------------
24 24
25 25 #-----------------------------------------------------------------------------
26 26 # Imports
27 27 #-----------------------------------------------------------------------------
28 28 from __future__ import print_function
29 29
30 30 # Stdlib imports
31 from ast import PyCF_ONLY_AST
31 32 import codeop
32 33 import hashlib
33 34 import linecache
34 35 import time
35 36
36 37 #-----------------------------------------------------------------------------
37 38 # Local utilities
38 39 #-----------------------------------------------------------------------------
39 40
40 41 def code_name(code, number=0):
41 42 """ Compute a (probably) unique name for code for caching.
42 43
43 44 This now expects code to be unicode.
44 45 """
45 46 hash_digest = hashlib.md5(code.encode("utf-8")).hexdigest()
46 47 # Include the number and 12 characters of the hash in the name. It's
47 48 # pretty much impossible that in a single session we'll have collisions
48 49 # even with truncated hashes, and the full one makes tracebacks too long
49 50 return '<ipython-input-{0}-{1}>'.format(number, hash_digest[:12])
50 51
51 52 #-----------------------------------------------------------------------------
52 53 # Classes and functions
53 54 #-----------------------------------------------------------------------------
54 55
55 56 class CachingCompiler(codeop.Compile):
56 57 """A compiler that caches code compiled from interactive statements.
57 58 """
58 59
59 60 def __init__(self):
60 61 codeop.Compile.__init__(self)
61 62
62 63 # This is ugly, but it must be done this way to allow multiple
63 64 # simultaneous ipython instances to coexist. Since Python itself
64 65 # directly accesses the data structures in the linecache module, and
65 66 # the cache therein is global, we must work with that data structure.
66 67 # We must hold a reference to the original checkcache routine and call
67 68 # that in our own check_cache() below, but the special IPython cache
68 69 # must also be shared by all IPython instances. If we were to hold
69 70 # separate caches (one in each CachingCompiler instance), any call made
70 71 # by Python itself to linecache.checkcache() would obliterate the
71 72 # cached data from the other IPython instances.
72 73 if not hasattr(linecache, '_ipython_cache'):
73 74 linecache._ipython_cache = {}
74 75 if not hasattr(linecache, '_checkcache_ori'):
75 76 linecache._checkcache_ori = linecache.checkcache
76 77 # Now, we must monkeypatch the linecache directly so that parts of the
77 78 # stdlib that call it outside our control go through our codepath
78 79 # (otherwise we'd lose our tracebacks).
79 80 linecache.checkcache = self.check_cache
80 81
82 def ast_parse(self, source, filename='<unknown>', symbol='exec'):
83 """Parse code to an AST with the current compiler flags active."""
84 return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1)
85
86 def reset_compiler_flags(self):
87 """Reset compiler flags to default state."""
88 # This value is copied from codeop.Compile.__init__, so if that ever
89 # changes, it will need to be updated.
90 self.flags = codeop.PyCF_DONT_IMPLY_DEDENT
91
81 92 @property
82 93 def compiler_flags(self):
83 94 """Flags currently active in the compilation process.
84 95 """
85 96 return self.flags
86 97
87 98 def cache(self, code, number=0):
88 99 """Make a name for a block of code, and cache the code.
89 100
90 101 Parameters
91 102 ----------
92 103 code : str
93 104 The Python source code to cache.
94 105 number : int
95 106 A number which forms part of the code's name. Used for the execution
96 107 counter.
97 108
98 109 Returns
99 110 -------
100 111 The name of the cached code (as a string). Pass this as the filename
101 112 argument to compilation, so that tracebacks are correctly hooked up.
102 113 """
103 114 name = code_name(code, number)
104 115 entry = (len(code), time.time(),
105 116 [line+'\n' for line in code.splitlines()], name)
106 117 linecache.cache[name] = entry
107 118 linecache._ipython_cache[name] = entry
108 119 return name
109 120
110 121 def check_cache(self, *args):
111 122 """Call linecache.checkcache() safely protecting our cached values.
112 123 """
113 124 # First call the orignal checkcache as intended
114 125 linecache._checkcache_ori(*args)
115 126 # Then, update back the cache with our data, so that tracebacks related
116 127 # to our compiled codes can be produced.
117 128 linecache.cache.update(linecache._ipython_cache)
@@ -1,2580 +1,2580 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__ as builtin_mod
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 try:
33 33 from contextlib import nested
34 34 except:
35 35 from IPython.utils.nested_context import nested
36 36
37 37 from IPython.config.configurable import SingletonConfigurable
38 38 from IPython.core import debugger, oinspect
39 39 from IPython.core import history as ipcorehist
40 40 from IPython.core import page
41 41 from IPython.core import prefilter
42 42 from IPython.core import shadowns
43 43 from IPython.core import ultratb
44 44 from IPython.core.alias import AliasManager, AliasError
45 45 from IPython.core.autocall import ExitAutocall
46 46 from IPython.core.builtin_trap import BuiltinTrap
47 47 from IPython.core.compilerop import CachingCompiler
48 48 from IPython.core.display_trap import DisplayTrap
49 49 from IPython.core.displayhook import DisplayHook
50 50 from IPython.core.displaypub import DisplayPublisher
51 51 from IPython.core.error import TryNext, UsageError
52 52 from IPython.core.extensions import ExtensionManager
53 53 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
54 54 from IPython.core.formatters import DisplayFormatter
55 55 from IPython.core.history import HistoryManager
56 56 from IPython.core.inputsplitter import IPythonInputSplitter
57 57 from IPython.core.logger import Logger
58 58 from IPython.core.macro import Macro
59 59 from IPython.core.magic import Magic
60 60 from IPython.core.payload import PayloadManager
61 61 from IPython.core.plugin import PluginManager
62 62 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
63 63 from IPython.core.profiledir import ProfileDir
64 64 from IPython.external.Itpl import ItplNS
65 65 from IPython.utils import PyColorize
66 66 from IPython.utils import io
67 67 from IPython.utils import py3compat
68 68 from IPython.utils.doctestreload import doctest_reload
69 69 from IPython.utils.io import ask_yes_no, rprint
70 70 from IPython.utils.ipstruct import Struct
71 71 from IPython.utils.path import get_home_dir, get_ipython_dir, HomeDirError
72 72 from IPython.utils.pickleshare import PickleShareDB
73 73 from IPython.utils.process import system, getoutput
74 74 from IPython.utils.strdispatch import StrDispatch
75 75 from IPython.utils.syspathcontext import prepended_to_syspath
76 76 from IPython.utils.text import num_ini_spaces, format_screen, LSString, SList
77 77 from IPython.utils.traitlets import (Int, CBool, CaselessStrEnum, Enum,
78 78 List, Unicode, Instance, Type)
79 79 from IPython.utils.warn import warn, error, fatal
80 80 import IPython.core.hooks
81 81
82 82 #-----------------------------------------------------------------------------
83 83 # Globals
84 84 #-----------------------------------------------------------------------------
85 85
86 86 # compiled regexps for autoindent management
87 87 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
88 88
89 89 #-----------------------------------------------------------------------------
90 90 # Utilities
91 91 #-----------------------------------------------------------------------------
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 # We save this here in case user code replaces raw_input, but it needs
415 415 # to be after init_readline(), because PyPy's readline works by replacing
416 416 # raw_input.
417 417 if py3compat.PY3:
418 418 self.raw_input_original = input
419 419 else:
420 420 self.raw_input_original = raw_input
421 421 # init_completer must come after init_readline, because it needs to
422 422 # know whether readline is present or not system-wide to configure the
423 423 # completers, since the completion machinery can now operate
424 424 # independently of readline (e.g. over the network)
425 425 self.init_completer()
426 426 # TODO: init_io() needs to happen before init_traceback handlers
427 427 # because the traceback handlers hardcode the stdout/stderr streams.
428 428 # This logic in in debugger.Pdb and should eventually be changed.
429 429 self.init_io()
430 430 self.init_traceback_handlers(custom_exceptions)
431 431 self.init_prompts()
432 432 self.init_display_formatter()
433 433 self.init_display_pub()
434 434 self.init_displayhook()
435 435 self.init_reload_doctest()
436 436 self.init_magics()
437 437 self.init_pdb()
438 438 self.init_extension_manager()
439 439 self.init_plugin_manager()
440 440 self.init_payload()
441 441 self.hooks.late_startup_hook()
442 442 atexit.register(self.atexit_operations)
443 443
444 444 def get_ipython(self):
445 445 """Return the currently running IPython instance."""
446 446 return self
447 447
448 448 #-------------------------------------------------------------------------
449 449 # Trait changed handlers
450 450 #-------------------------------------------------------------------------
451 451
452 452 def _ipython_dir_changed(self, name, new):
453 453 if not os.path.isdir(new):
454 454 os.makedirs(new, mode = 0777)
455 455
456 456 def set_autoindent(self,value=None):
457 457 """Set the autoindent flag, checking for readline support.
458 458
459 459 If called with no arguments, it acts as a toggle."""
460 460
461 461 if not self.has_readline:
462 462 if os.name == 'posix':
463 463 warn("The auto-indent feature requires the readline library")
464 464 self.autoindent = 0
465 465 return
466 466 if value is None:
467 467 self.autoindent = not self.autoindent
468 468 else:
469 469 self.autoindent = value
470 470
471 471 #-------------------------------------------------------------------------
472 472 # init_* methods called by __init__
473 473 #-------------------------------------------------------------------------
474 474
475 475 def init_ipython_dir(self, ipython_dir):
476 476 if ipython_dir is not None:
477 477 self.ipython_dir = ipython_dir
478 478 return
479 479
480 480 self.ipython_dir = get_ipython_dir()
481 481
482 482 def init_profile_dir(self, profile_dir):
483 483 if profile_dir is not None:
484 484 self.profile_dir = profile_dir
485 485 return
486 486 self.profile_dir =\
487 487 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
488 488
489 489 def init_instance_attrs(self):
490 490 self.more = False
491 491
492 492 # command compiler
493 493 self.compile = CachingCompiler()
494 494
495 495 # Make an empty namespace, which extension writers can rely on both
496 496 # existing and NEVER being used by ipython itself. This gives them a
497 497 # convenient location for storing additional information and state
498 498 # their extensions may require, without fear of collisions with other
499 499 # ipython names that may develop later.
500 500 self.meta = Struct()
501 501
502 502 # Temporary files used for various purposes. Deleted at exit.
503 503 self.tempfiles = []
504 504
505 505 # Keep track of readline usage (later set by init_readline)
506 506 self.has_readline = False
507 507
508 508 # keep track of where we started running (mainly for crash post-mortem)
509 509 # This is not being used anywhere currently.
510 510 self.starting_dir = os.getcwdu()
511 511
512 512 # Indentation management
513 513 self.indent_current_nsp = 0
514 514
515 515 # Dict to track post-execution functions that have been registered
516 516 self._post_execute = {}
517 517
518 518 def init_environment(self):
519 519 """Any changes we need to make to the user's environment."""
520 520 pass
521 521
522 522 def init_encoding(self):
523 523 # Get system encoding at startup time. Certain terminals (like Emacs
524 524 # under Win32 have it set to None, and we need to have a known valid
525 525 # encoding to use in the raw_input() method
526 526 try:
527 527 self.stdin_encoding = sys.stdin.encoding or 'ascii'
528 528 except AttributeError:
529 529 self.stdin_encoding = 'ascii'
530 530
531 531 def init_syntax_highlighting(self):
532 532 # Python source parser/formatter for syntax highlighting
533 533 pyformat = PyColorize.Parser().format
534 534 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
535 535
536 536 def init_pushd_popd_magic(self):
537 537 # for pushd/popd management
538 538 try:
539 539 self.home_dir = get_home_dir()
540 540 except HomeDirError, msg:
541 541 fatal(msg)
542 542
543 543 self.dir_stack = []
544 544
545 545 def init_logger(self):
546 546 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
547 547 logmode='rotate')
548 548
549 549 def init_logstart(self):
550 550 """Initialize logging in case it was requested at the command line.
551 551 """
552 552 if self.logappend:
553 553 self.magic_logstart(self.logappend + ' append')
554 554 elif self.logfile:
555 555 self.magic_logstart(self.logfile)
556 556 elif self.logstart:
557 557 self.magic_logstart()
558 558
559 559 def init_builtins(self):
560 560 self.builtin_trap = BuiltinTrap(shell=self)
561 561
562 562 def init_inspector(self):
563 563 # Object inspector
564 564 self.inspector = oinspect.Inspector(oinspect.InspectColors,
565 565 PyColorize.ANSICodeColors,
566 566 'NoColor',
567 567 self.object_info_string_level)
568 568
569 569 def init_io(self):
570 570 # This will just use sys.stdout and sys.stderr. If you want to
571 571 # override sys.stdout and sys.stderr themselves, you need to do that
572 572 # *before* instantiating this class, because io holds onto
573 573 # references to the underlying streams.
574 574 if sys.platform == 'win32' and self.has_readline:
575 575 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
576 576 else:
577 577 io.stdout = io.IOStream(sys.stdout)
578 578 io.stderr = io.IOStream(sys.stderr)
579 579
580 580 def init_prompts(self):
581 581 # TODO: This is a pass for now because the prompts are managed inside
582 582 # the DisplayHook. Once there is a separate prompt manager, this
583 583 # will initialize that object and all prompt related information.
584 584 pass
585 585
586 586 def init_display_formatter(self):
587 587 self.display_formatter = DisplayFormatter(config=self.config)
588 588
589 589 def init_display_pub(self):
590 590 self.display_pub = self.display_pub_class(config=self.config)
591 591
592 592 def init_displayhook(self):
593 593 # Initialize displayhook, set in/out prompts and printing system
594 594 self.displayhook = self.displayhook_class(
595 595 config=self.config,
596 596 shell=self,
597 597 cache_size=self.cache_size,
598 598 input_sep = self.separate_in,
599 599 output_sep = self.separate_out,
600 600 output_sep2 = self.separate_out2,
601 601 ps1 = self.prompt_in1,
602 602 ps2 = self.prompt_in2,
603 603 ps_out = self.prompt_out,
604 604 pad_left = self.prompts_pad_left
605 605 )
606 606 # This is a context manager that installs/revmoes the displayhook at
607 607 # the appropriate time.
608 608 self.display_trap = DisplayTrap(hook=self.displayhook)
609 609
610 610 def init_reload_doctest(self):
611 611 # Do a proper resetting of doctest, including the necessary displayhook
612 612 # monkeypatching
613 613 try:
614 614 doctest_reload()
615 615 except ImportError:
616 616 warn("doctest module does not exist.")
617 617
618 618 #-------------------------------------------------------------------------
619 619 # Things related to injections into the sys module
620 620 #-------------------------------------------------------------------------
621 621
622 622 def save_sys_module_state(self):
623 623 """Save the state of hooks in the sys module.
624 624
625 625 This has to be called after self.user_ns is created.
626 626 """
627 627 self._orig_sys_module_state = {}
628 628 self._orig_sys_module_state['stdin'] = sys.stdin
629 629 self._orig_sys_module_state['stdout'] = sys.stdout
630 630 self._orig_sys_module_state['stderr'] = sys.stderr
631 631 self._orig_sys_module_state['excepthook'] = sys.excepthook
632 632 try:
633 633 self._orig_sys_modules_main_name = self.user_ns['__name__']
634 634 except KeyError:
635 635 pass
636 636
637 637 def restore_sys_module_state(self):
638 638 """Restore the state of the sys module."""
639 639 try:
640 640 for k, v in self._orig_sys_module_state.iteritems():
641 641 setattr(sys, k, v)
642 642 except AttributeError:
643 643 pass
644 644 # Reset what what done in self.init_sys_modules
645 645 try:
646 646 sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
647 647 except (AttributeError, KeyError):
648 648 pass
649 649
650 650 #-------------------------------------------------------------------------
651 651 # Things related to hooks
652 652 #-------------------------------------------------------------------------
653 653
654 654 def init_hooks(self):
655 655 # hooks holds pointers used for user-side customizations
656 656 self.hooks = Struct()
657 657
658 658 self.strdispatchers = {}
659 659
660 660 # Set all default hooks, defined in the IPython.hooks module.
661 661 hooks = IPython.core.hooks
662 662 for hook_name in hooks.__all__:
663 663 # default hooks have priority 100, i.e. low; user hooks should have
664 664 # 0-100 priority
665 665 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
666 666
667 667 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
668 668 """set_hook(name,hook) -> sets an internal IPython hook.
669 669
670 670 IPython exposes some of its internal API as user-modifiable hooks. By
671 671 adding your function to one of these hooks, you can modify IPython's
672 672 behavior to call at runtime your own routines."""
673 673
674 674 # At some point in the future, this should validate the hook before it
675 675 # accepts it. Probably at least check that the hook takes the number
676 676 # of args it's supposed to.
677 677
678 678 f = types.MethodType(hook,self)
679 679
680 680 # check if the hook is for strdispatcher first
681 681 if str_key is not None:
682 682 sdp = self.strdispatchers.get(name, StrDispatch())
683 683 sdp.add_s(str_key, f, priority )
684 684 self.strdispatchers[name] = sdp
685 685 return
686 686 if re_key is not None:
687 687 sdp = self.strdispatchers.get(name, StrDispatch())
688 688 sdp.add_re(re.compile(re_key), f, priority )
689 689 self.strdispatchers[name] = sdp
690 690 return
691 691
692 692 dp = getattr(self.hooks, name, None)
693 693 if name not in IPython.core.hooks.__all__:
694 694 print "Warning! Hook '%s' is not one of %s" % \
695 695 (name, IPython.core.hooks.__all__ )
696 696 if not dp:
697 697 dp = IPython.core.hooks.CommandChainDispatcher()
698 698
699 699 try:
700 700 dp.add(f,priority)
701 701 except AttributeError:
702 702 # it was not commandchain, plain old func - replace
703 703 dp = f
704 704
705 705 setattr(self.hooks,name, dp)
706 706
707 707 def register_post_execute(self, func):
708 708 """Register a function for calling after code execution.
709 709 """
710 710 if not callable(func):
711 711 raise ValueError('argument %s must be callable' % func)
712 712 self._post_execute[func] = True
713 713
714 714 #-------------------------------------------------------------------------
715 715 # Things related to the "main" module
716 716 #-------------------------------------------------------------------------
717 717
718 718 def new_main_mod(self,ns=None):
719 719 """Return a new 'main' module object for user code execution.
720 720 """
721 721 main_mod = self._user_main_module
722 722 init_fakemod_dict(main_mod,ns)
723 723 return main_mod
724 724
725 725 def cache_main_mod(self,ns,fname):
726 726 """Cache a main module's namespace.
727 727
728 728 When scripts are executed via %run, we must keep a reference to the
729 729 namespace of their __main__ module (a FakeModule instance) around so
730 730 that Python doesn't clear it, rendering objects defined therein
731 731 useless.
732 732
733 733 This method keeps said reference in a private dict, keyed by the
734 734 absolute path of the module object (which corresponds to the script
735 735 path). This way, for multiple executions of the same script we only
736 736 keep one copy of the namespace (the last one), thus preventing memory
737 737 leaks from old references while allowing the objects from the last
738 738 execution to be accessible.
739 739
740 740 Note: we can not allow the actual FakeModule instances to be deleted,
741 741 because of how Python tears down modules (it hard-sets all their
742 742 references to None without regard for reference counts). This method
743 743 must therefore make a *copy* of the given namespace, to allow the
744 744 original module's __dict__ to be cleared and reused.
745 745
746 746
747 747 Parameters
748 748 ----------
749 749 ns : a namespace (a dict, typically)
750 750
751 751 fname : str
752 752 Filename associated with the namespace.
753 753
754 754 Examples
755 755 --------
756 756
757 757 In [10]: import IPython
758 758
759 759 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
760 760
761 761 In [12]: IPython.__file__ in _ip._main_ns_cache
762 762 Out[12]: True
763 763 """
764 764 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
765 765
766 766 def clear_main_mod_cache(self):
767 767 """Clear the cache of main modules.
768 768
769 769 Mainly for use by utilities like %reset.
770 770
771 771 Examples
772 772 --------
773 773
774 774 In [15]: import IPython
775 775
776 776 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
777 777
778 778 In [17]: len(_ip._main_ns_cache) > 0
779 779 Out[17]: True
780 780
781 781 In [18]: _ip.clear_main_mod_cache()
782 782
783 783 In [19]: len(_ip._main_ns_cache) == 0
784 784 Out[19]: True
785 785 """
786 786 self._main_ns_cache.clear()
787 787
788 788 #-------------------------------------------------------------------------
789 789 # Things related to debugging
790 790 #-------------------------------------------------------------------------
791 791
792 792 def init_pdb(self):
793 793 # Set calling of pdb on exceptions
794 794 # self.call_pdb is a property
795 795 self.call_pdb = self.pdb
796 796
797 797 def _get_call_pdb(self):
798 798 return self._call_pdb
799 799
800 800 def _set_call_pdb(self,val):
801 801
802 802 if val not in (0,1,False,True):
803 803 raise ValueError,'new call_pdb value must be boolean'
804 804
805 805 # store value in instance
806 806 self._call_pdb = val
807 807
808 808 # notify the actual exception handlers
809 809 self.InteractiveTB.call_pdb = val
810 810
811 811 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
812 812 'Control auto-activation of pdb at exceptions')
813 813
814 814 def debugger(self,force=False):
815 815 """Call the pydb/pdb debugger.
816 816
817 817 Keywords:
818 818
819 819 - force(False): by default, this routine checks the instance call_pdb
820 820 flag and does not actually invoke the debugger if the flag is false.
821 821 The 'force' option forces the debugger to activate even if the flag
822 822 is false.
823 823 """
824 824
825 825 if not (force or self.call_pdb):
826 826 return
827 827
828 828 if not hasattr(sys,'last_traceback'):
829 829 error('No traceback has been produced, nothing to debug.')
830 830 return
831 831
832 832 # use pydb if available
833 833 if debugger.has_pydb:
834 834 from pydb import pm
835 835 else:
836 836 # fallback to our internal debugger
837 837 pm = lambda : self.InteractiveTB.debugger(force=True)
838 838
839 839 with self.readline_no_record:
840 840 pm()
841 841
842 842 #-------------------------------------------------------------------------
843 843 # Things related to IPython's various namespaces
844 844 #-------------------------------------------------------------------------
845 845
846 846 def init_create_namespaces(self, user_ns=None, user_global_ns=None):
847 847 # Create the namespace where the user will operate. user_ns is
848 848 # normally the only one used, and it is passed to the exec calls as
849 849 # the locals argument. But we do carry a user_global_ns namespace
850 850 # given as the exec 'globals' argument, This is useful in embedding
851 851 # situations where the ipython shell opens in a context where the
852 852 # distinction between locals and globals is meaningful. For
853 853 # non-embedded contexts, it is just the same object as the user_ns dict.
854 854
855 855 # FIXME. For some strange reason, __builtins__ is showing up at user
856 856 # level as a dict instead of a module. This is a manual fix, but I
857 857 # should really track down where the problem is coming from. Alex
858 858 # Schmolck reported this problem first.
859 859
860 860 # A useful post by Alex Martelli on this topic:
861 861 # Re: inconsistent value from __builtins__
862 862 # Von: Alex Martelli <aleaxit@yahoo.com>
863 863 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
864 864 # Gruppen: comp.lang.python
865 865
866 866 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
867 867 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
868 868 # > <type 'dict'>
869 869 # > >>> print type(__builtins__)
870 870 # > <type 'module'>
871 871 # > Is this difference in return value intentional?
872 872
873 873 # Well, it's documented that '__builtins__' can be either a dictionary
874 874 # or a module, and it's been that way for a long time. Whether it's
875 875 # intentional (or sensible), I don't know. In any case, the idea is
876 876 # that if you need to access the built-in namespace directly, you
877 877 # should start with "import __builtin__" (note, no 's') which will
878 878 # definitely give you a module. Yeah, it's somewhat confusing:-(.
879 879
880 880 # These routines return properly built dicts as needed by the rest of
881 881 # the code, and can also be used by extension writers to generate
882 882 # properly initialized namespaces.
883 883 user_ns, user_global_ns = self.make_user_namespaces(user_ns,
884 884 user_global_ns)
885 885
886 886 # Assign namespaces
887 887 # This is the namespace where all normal user variables live
888 888 self.user_ns = user_ns
889 889 self.user_global_ns = user_global_ns
890 890
891 891 # An auxiliary namespace that checks what parts of the user_ns were
892 892 # loaded at startup, so we can list later only variables defined in
893 893 # actual interactive use. Since it is always a subset of user_ns, it
894 894 # doesn't need to be separately tracked in the ns_table.
895 895 self.user_ns_hidden = {}
896 896
897 897 # A namespace to keep track of internal data structures to prevent
898 898 # them from cluttering user-visible stuff. Will be updated later
899 899 self.internal_ns = {}
900 900
901 901 # Now that FakeModule produces a real module, we've run into a nasty
902 902 # problem: after script execution (via %run), the module where the user
903 903 # code ran is deleted. Now that this object is a true module (needed
904 904 # so docetst and other tools work correctly), the Python module
905 905 # teardown mechanism runs over it, and sets to None every variable
906 906 # present in that module. Top-level references to objects from the
907 907 # script survive, because the user_ns is updated with them. However,
908 908 # calling functions defined in the script that use other things from
909 909 # the script will fail, because the function's closure had references
910 910 # to the original objects, which are now all None. So we must protect
911 911 # these modules from deletion by keeping a cache.
912 912 #
913 913 # To avoid keeping stale modules around (we only need the one from the
914 914 # last run), we use a dict keyed with the full path to the script, so
915 915 # only the last version of the module is held in the cache. Note,
916 916 # however, that we must cache the module *namespace contents* (their
917 917 # __dict__). Because if we try to cache the actual modules, old ones
918 918 # (uncached) could be destroyed while still holding references (such as
919 919 # those held by GUI objects that tend to be long-lived)>
920 920 #
921 921 # The %reset command will flush this cache. See the cache_main_mod()
922 922 # and clear_main_mod_cache() methods for details on use.
923 923
924 924 # This is the cache used for 'main' namespaces
925 925 self._main_ns_cache = {}
926 926 # And this is the single instance of FakeModule whose __dict__ we keep
927 927 # copying and clearing for reuse on each %run
928 928 self._user_main_module = FakeModule()
929 929
930 930 # A table holding all the namespaces IPython deals with, so that
931 931 # introspection facilities can search easily.
932 932 self.ns_table = {'user':user_ns,
933 933 'user_global':user_global_ns,
934 934 'internal':self.internal_ns,
935 935 'builtin':builtin_mod.__dict__
936 936 }
937 937
938 938 # Similarly, track all namespaces where references can be held and that
939 939 # we can safely clear (so it can NOT include builtin). This one can be
940 940 # a simple list. Note that the main execution namespaces, user_ns and
941 941 # user_global_ns, can NOT be listed here, as clearing them blindly
942 942 # causes errors in object __del__ methods. Instead, the reset() method
943 943 # clears them manually and carefully.
944 944 self.ns_refs_table = [ self.user_ns_hidden,
945 945 self.internal_ns, self._main_ns_cache ]
946 946
947 947 def make_user_namespaces(self, user_ns=None, user_global_ns=None):
948 948 """Return a valid local and global user interactive namespaces.
949 949
950 950 This builds a dict with the minimal information needed to operate as a
951 951 valid IPython user namespace, which you can pass to the various
952 952 embedding classes in ipython. The default implementation returns the
953 953 same dict for both the locals and the globals to allow functions to
954 954 refer to variables in the namespace. Customized implementations can
955 955 return different dicts. The locals dictionary can actually be anything
956 956 following the basic mapping protocol of a dict, but the globals dict
957 957 must be a true dict, not even a subclass. It is recommended that any
958 958 custom object for the locals namespace synchronize with the globals
959 959 dict somehow.
960 960
961 961 Raises TypeError if the provided globals namespace is not a true dict.
962 962
963 963 Parameters
964 964 ----------
965 965 user_ns : dict-like, optional
966 966 The current user namespace. The items in this namespace should
967 967 be included in the output. If None, an appropriate blank
968 968 namespace should be created.
969 969 user_global_ns : dict, optional
970 970 The current user global namespace. The items in this namespace
971 971 should be included in the output. If None, an appropriate
972 972 blank namespace should be created.
973 973
974 974 Returns
975 975 -------
976 976 A pair of dictionary-like object to be used as the local namespace
977 977 of the interpreter and a dict to be used as the global namespace.
978 978 """
979 979
980 980
981 981 # We must ensure that __builtin__ (without the final 's') is always
982 982 # available and pointing to the __builtin__ *module*. For more details:
983 983 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
984 984
985 985 if user_ns is None:
986 986 # Set __name__ to __main__ to better match the behavior of the
987 987 # normal interpreter.
988 988 user_ns = {'__name__' :'__main__',
989 989 py3compat.builtin_mod_name: builtin_mod,
990 990 '__builtins__' : builtin_mod,
991 991 }
992 992 else:
993 993 user_ns.setdefault('__name__','__main__')
994 994 user_ns.setdefault(py3compat.builtin_mod_name,builtin_mod)
995 995 user_ns.setdefault('__builtins__',builtin_mod)
996 996
997 997 if user_global_ns is None:
998 998 user_global_ns = user_ns
999 999 if type(user_global_ns) is not dict:
1000 1000 raise TypeError("user_global_ns must be a true dict; got %r"
1001 1001 % type(user_global_ns))
1002 1002
1003 1003 return user_ns, user_global_ns
1004 1004
1005 1005 def init_sys_modules(self):
1006 1006 # We need to insert into sys.modules something that looks like a
1007 1007 # module but which accesses the IPython namespace, for shelve and
1008 1008 # pickle to work interactively. Normally they rely on getting
1009 1009 # everything out of __main__, but for embedding purposes each IPython
1010 1010 # instance has its own private namespace, so we can't go shoving
1011 1011 # everything into __main__.
1012 1012
1013 1013 # note, however, that we should only do this for non-embedded
1014 1014 # ipythons, which really mimic the __main__.__dict__ with their own
1015 1015 # namespace. Embedded instances, on the other hand, should not do
1016 1016 # this because they need to manage the user local/global namespaces
1017 1017 # only, but they live within a 'normal' __main__ (meaning, they
1018 1018 # shouldn't overtake the execution environment of the script they're
1019 1019 # embedded in).
1020 1020
1021 1021 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1022 1022
1023 1023 try:
1024 1024 main_name = self.user_ns['__name__']
1025 1025 except KeyError:
1026 1026 raise KeyError('user_ns dictionary MUST have a "__name__" key')
1027 1027 else:
1028 1028 sys.modules[main_name] = FakeModule(self.user_ns)
1029 1029
1030 1030 def init_user_ns(self):
1031 1031 """Initialize all user-visible namespaces to their minimum defaults.
1032 1032
1033 1033 Certain history lists are also initialized here, as they effectively
1034 1034 act as user namespaces.
1035 1035
1036 1036 Notes
1037 1037 -----
1038 1038 All data structures here are only filled in, they are NOT reset by this
1039 1039 method. If they were not empty before, data will simply be added to
1040 1040 therm.
1041 1041 """
1042 1042 # This function works in two parts: first we put a few things in
1043 1043 # user_ns, and we sync that contents into user_ns_hidden so that these
1044 1044 # initial variables aren't shown by %who. After the sync, we add the
1045 1045 # rest of what we *do* want the user to see with %who even on a new
1046 1046 # session (probably nothing, so theye really only see their own stuff)
1047 1047
1048 1048 # The user dict must *always* have a __builtin__ reference to the
1049 1049 # Python standard __builtin__ namespace, which must be imported.
1050 1050 # This is so that certain operations in prompt evaluation can be
1051 1051 # reliably executed with builtins. Note that we can NOT use
1052 1052 # __builtins__ (note the 's'), because that can either be a dict or a
1053 1053 # module, and can even mutate at runtime, depending on the context
1054 1054 # (Python makes no guarantees on it). In contrast, __builtin__ is
1055 1055 # always a module object, though it must be explicitly imported.
1056 1056
1057 1057 # For more details:
1058 1058 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1059 1059 ns = dict(__builtin__ = builtin_mod)
1060 1060
1061 1061 # Put 'help' in the user namespace
1062 1062 try:
1063 1063 from site import _Helper
1064 1064 ns['help'] = _Helper()
1065 1065 except ImportError:
1066 1066 warn('help() not available - check site.py')
1067 1067
1068 1068 # make global variables for user access to the histories
1069 1069 ns['_ih'] = self.history_manager.input_hist_parsed
1070 1070 ns['_oh'] = self.history_manager.output_hist
1071 1071 ns['_dh'] = self.history_manager.dir_hist
1072 1072
1073 1073 ns['_sh'] = shadowns
1074 1074
1075 1075 # user aliases to input and output histories. These shouldn't show up
1076 1076 # in %who, as they can have very large reprs.
1077 1077 ns['In'] = self.history_manager.input_hist_parsed
1078 1078 ns['Out'] = self.history_manager.output_hist
1079 1079
1080 1080 # Store myself as the public api!!!
1081 1081 ns['get_ipython'] = self.get_ipython
1082 1082
1083 1083 ns['exit'] = self.exiter
1084 1084 ns['quit'] = self.exiter
1085 1085
1086 1086 # Sync what we've added so far to user_ns_hidden so these aren't seen
1087 1087 # by %who
1088 1088 self.user_ns_hidden.update(ns)
1089 1089
1090 1090 # Anything put into ns now would show up in %who. Think twice before
1091 1091 # putting anything here, as we really want %who to show the user their
1092 1092 # stuff, not our variables.
1093 1093
1094 1094 # Finally, update the real user's namespace
1095 1095 self.user_ns.update(ns)
1096 1096
1097 1097 def reset(self, new_session=True):
1098 1098 """Clear all internal namespaces, and attempt to release references to
1099 1099 user objects.
1100 1100
1101 1101 If new_session is True, a new history session will be opened.
1102 1102 """
1103 1103 # Clear histories
1104 1104 self.history_manager.reset(new_session)
1105 1105 # Reset counter used to index all histories
1106 1106 if new_session:
1107 1107 self.execution_count = 1
1108 1108
1109 1109 # Flush cached output items
1110 1110 if self.displayhook.do_full_cache:
1111 1111 self.displayhook.flush()
1112 1112
1113 1113 # Restore the user namespaces to minimal usability
1114 1114 for ns in self.ns_refs_table:
1115 1115 ns.clear()
1116 1116
1117 1117 # The main execution namespaces must be cleared very carefully,
1118 1118 # skipping the deletion of the builtin-related keys, because doing so
1119 1119 # would cause errors in many object's __del__ methods.
1120 1120 for ns in [self.user_ns, self.user_global_ns]:
1121 1121 drop_keys = set(ns.keys())
1122 1122 drop_keys.discard('__builtin__')
1123 1123 drop_keys.discard('__builtins__')
1124 1124 for k in drop_keys:
1125 1125 del ns[k]
1126 1126
1127 1127 # Restore the user namespaces to minimal usability
1128 1128 self.init_user_ns()
1129 1129
1130 1130 # Restore the default and user aliases
1131 1131 self.alias_manager.clear_aliases()
1132 1132 self.alias_manager.init_aliases()
1133 1133
1134 1134 # Flush the private list of module references kept for script
1135 1135 # execution protection
1136 1136 self.clear_main_mod_cache()
1137 1137
1138 1138 # Clear out the namespace from the last %run
1139 1139 self.new_main_mod()
1140 1140
1141 1141 def del_var(self, varname, by_name=False):
1142 1142 """Delete a variable from the various namespaces, so that, as
1143 1143 far as possible, we're not keeping any hidden references to it.
1144 1144
1145 1145 Parameters
1146 1146 ----------
1147 1147 varname : str
1148 1148 The name of the variable to delete.
1149 1149 by_name : bool
1150 1150 If True, delete variables with the given name in each
1151 1151 namespace. If False (default), find the variable in the user
1152 1152 namespace, and delete references to it.
1153 1153 """
1154 1154 if varname in ('__builtin__', '__builtins__'):
1155 1155 raise ValueError("Refusing to delete %s" % varname)
1156 1156 ns_refs = self.ns_refs_table + [self.user_ns,
1157 1157 self.user_global_ns, self._user_main_module.__dict__] +\
1158 1158 self._main_ns_cache.values()
1159 1159
1160 1160 if by_name: # Delete by name
1161 1161 for ns in ns_refs:
1162 1162 try:
1163 1163 del ns[varname]
1164 1164 except KeyError:
1165 1165 pass
1166 1166 else: # Delete by object
1167 1167 try:
1168 1168 obj = self.user_ns[varname]
1169 1169 except KeyError:
1170 1170 raise NameError("name '%s' is not defined" % varname)
1171 1171 # Also check in output history
1172 1172 ns_refs.append(self.history_manager.output_hist)
1173 1173 for ns in ns_refs:
1174 1174 to_delete = [n for n, o in ns.iteritems() if o is obj]
1175 1175 for name in to_delete:
1176 1176 del ns[name]
1177 1177
1178 1178 # displayhook keeps extra references, but not in a dictionary
1179 1179 for name in ('_', '__', '___'):
1180 1180 if getattr(self.displayhook, name) is obj:
1181 1181 setattr(self.displayhook, name, None)
1182 1182
1183 1183 def reset_selective(self, regex=None):
1184 1184 """Clear selective variables from internal namespaces based on a
1185 1185 specified regular expression.
1186 1186
1187 1187 Parameters
1188 1188 ----------
1189 1189 regex : string or compiled pattern, optional
1190 1190 A regular expression pattern that will be used in searching
1191 1191 variable names in the users namespaces.
1192 1192 """
1193 1193 if regex is not None:
1194 1194 try:
1195 1195 m = re.compile(regex)
1196 1196 except TypeError:
1197 1197 raise TypeError('regex must be a string or compiled pattern')
1198 1198 # Search for keys in each namespace that match the given regex
1199 1199 # If a match is found, delete the key/value pair.
1200 1200 for ns in self.ns_refs_table:
1201 1201 for var in ns:
1202 1202 if m.search(var):
1203 1203 del ns[var]
1204 1204
1205 1205 def push(self, variables, interactive=True):
1206 1206 """Inject a group of variables into the IPython user namespace.
1207 1207
1208 1208 Parameters
1209 1209 ----------
1210 1210 variables : dict, str or list/tuple of str
1211 1211 The variables to inject into the user's namespace. If a dict, a
1212 1212 simple update is done. If a str, the string is assumed to have
1213 1213 variable names separated by spaces. A list/tuple of str can also
1214 1214 be used to give the variable names. If just the variable names are
1215 1215 give (list/tuple/str) then the variable values looked up in the
1216 1216 callers frame.
1217 1217 interactive : bool
1218 1218 If True (default), the variables will be listed with the ``who``
1219 1219 magic.
1220 1220 """
1221 1221 vdict = None
1222 1222
1223 1223 # We need a dict of name/value pairs to do namespace updates.
1224 1224 if isinstance(variables, dict):
1225 1225 vdict = variables
1226 1226 elif isinstance(variables, (basestring, list, tuple)):
1227 1227 if isinstance(variables, basestring):
1228 1228 vlist = variables.split()
1229 1229 else:
1230 1230 vlist = variables
1231 1231 vdict = {}
1232 1232 cf = sys._getframe(1)
1233 1233 for name in vlist:
1234 1234 try:
1235 1235 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1236 1236 except:
1237 1237 print ('Could not get variable %s from %s' %
1238 1238 (name,cf.f_code.co_name))
1239 1239 else:
1240 1240 raise ValueError('variables must be a dict/str/list/tuple')
1241 1241
1242 1242 # Propagate variables to user namespace
1243 1243 self.user_ns.update(vdict)
1244 1244
1245 1245 # And configure interactive visibility
1246 1246 config_ns = self.user_ns_hidden
1247 1247 if interactive:
1248 1248 for name, val in vdict.iteritems():
1249 1249 config_ns.pop(name, None)
1250 1250 else:
1251 1251 for name,val in vdict.iteritems():
1252 1252 config_ns[name] = val
1253 1253
1254 1254 #-------------------------------------------------------------------------
1255 1255 # Things related to object introspection
1256 1256 #-------------------------------------------------------------------------
1257 1257
1258 1258 def _ofind(self, oname, namespaces=None):
1259 1259 """Find an object in the available namespaces.
1260 1260
1261 1261 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1262 1262
1263 1263 Has special code to detect magic functions.
1264 1264 """
1265 1265 oname = oname.strip()
1266 1266 #print '1- oname: <%r>' % oname # dbg
1267 1267 if not py3compat.isidentifier(oname.lstrip(ESC_MAGIC), dotted=True):
1268 1268 return dict(found=False)
1269 1269
1270 1270 alias_ns = None
1271 1271 if namespaces is None:
1272 1272 # Namespaces to search in:
1273 1273 # Put them in a list. The order is important so that we
1274 1274 # find things in the same order that Python finds them.
1275 1275 namespaces = [ ('Interactive', self.user_ns),
1276 1276 ('IPython internal', self.internal_ns),
1277 1277 ('Python builtin', builtin_mod.__dict__),
1278 1278 ('Alias', self.alias_manager.alias_table),
1279 1279 ]
1280 1280 alias_ns = self.alias_manager.alias_table
1281 1281
1282 1282 # initialize results to 'null'
1283 1283 found = False; obj = None; ospace = None; ds = None;
1284 1284 ismagic = False; isalias = False; parent = None
1285 1285
1286 1286 # We need to special-case 'print', which as of python2.6 registers as a
1287 1287 # function but should only be treated as one if print_function was
1288 1288 # loaded with a future import. In this case, just bail.
1289 1289 if (oname == 'print' and not py3compat.PY3 and not \
1290 1290 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1291 1291 return {'found':found, 'obj':obj, 'namespace':ospace,
1292 1292 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1293 1293
1294 1294 # Look for the given name by splitting it in parts. If the head is
1295 1295 # found, then we look for all the remaining parts as members, and only
1296 1296 # declare success if we can find them all.
1297 1297 oname_parts = oname.split('.')
1298 1298 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1299 1299 for nsname,ns in namespaces:
1300 1300 try:
1301 1301 obj = ns[oname_head]
1302 1302 except KeyError:
1303 1303 continue
1304 1304 else:
1305 1305 #print 'oname_rest:', oname_rest # dbg
1306 1306 for part in oname_rest:
1307 1307 try:
1308 1308 parent = obj
1309 1309 obj = getattr(obj,part)
1310 1310 except:
1311 1311 # Blanket except b/c some badly implemented objects
1312 1312 # allow __getattr__ to raise exceptions other than
1313 1313 # AttributeError, which then crashes IPython.
1314 1314 break
1315 1315 else:
1316 1316 # If we finish the for loop (no break), we got all members
1317 1317 found = True
1318 1318 ospace = nsname
1319 1319 if ns == alias_ns:
1320 1320 isalias = True
1321 1321 break # namespace loop
1322 1322
1323 1323 # Try to see if it's magic
1324 1324 if not found:
1325 1325 if oname.startswith(ESC_MAGIC):
1326 1326 oname = oname[1:]
1327 1327 obj = getattr(self,'magic_'+oname,None)
1328 1328 if obj is not None:
1329 1329 found = True
1330 1330 ospace = 'IPython internal'
1331 1331 ismagic = True
1332 1332
1333 1333 # Last try: special-case some literals like '', [], {}, etc:
1334 1334 if not found and oname_head in ["''",'""','[]','{}','()']:
1335 1335 obj = eval(oname_head)
1336 1336 found = True
1337 1337 ospace = 'Interactive'
1338 1338
1339 1339 return {'found':found, 'obj':obj, 'namespace':ospace,
1340 1340 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1341 1341
1342 1342 def _ofind_property(self, oname, info):
1343 1343 """Second part of object finding, to look for property details."""
1344 1344 if info.found:
1345 1345 # Get the docstring of the class property if it exists.
1346 1346 path = oname.split('.')
1347 1347 root = '.'.join(path[:-1])
1348 1348 if info.parent is not None:
1349 1349 try:
1350 1350 target = getattr(info.parent, '__class__')
1351 1351 # The object belongs to a class instance.
1352 1352 try:
1353 1353 target = getattr(target, path[-1])
1354 1354 # The class defines the object.
1355 1355 if isinstance(target, property):
1356 1356 oname = root + '.__class__.' + path[-1]
1357 1357 info = Struct(self._ofind(oname))
1358 1358 except AttributeError: pass
1359 1359 except AttributeError: pass
1360 1360
1361 1361 # We return either the new info or the unmodified input if the object
1362 1362 # hadn't been found
1363 1363 return info
1364 1364
1365 1365 def _object_find(self, oname, namespaces=None):
1366 1366 """Find an object and return a struct with info about it."""
1367 1367 inf = Struct(self._ofind(oname, namespaces))
1368 1368 return Struct(self._ofind_property(oname, inf))
1369 1369
1370 1370 def _inspect(self, meth, oname, namespaces=None, **kw):
1371 1371 """Generic interface to the inspector system.
1372 1372
1373 1373 This function is meant to be called by pdef, pdoc & friends."""
1374 1374 info = self._object_find(oname)
1375 1375 if info.found:
1376 1376 pmethod = getattr(self.inspector, meth)
1377 1377 formatter = format_screen if info.ismagic else None
1378 1378 if meth == 'pdoc':
1379 1379 pmethod(info.obj, oname, formatter)
1380 1380 elif meth == 'pinfo':
1381 1381 pmethod(info.obj, oname, formatter, info, **kw)
1382 1382 else:
1383 1383 pmethod(info.obj, oname)
1384 1384 else:
1385 1385 print 'Object `%s` not found.' % oname
1386 1386 return 'not found' # so callers can take other action
1387 1387
1388 1388 def object_inspect(self, oname):
1389 1389 with self.builtin_trap:
1390 1390 info = self._object_find(oname)
1391 1391 if info.found:
1392 1392 return self.inspector.info(info.obj, oname, info=info)
1393 1393 else:
1394 1394 return oinspect.object_info(name=oname, found=False)
1395 1395
1396 1396 #-------------------------------------------------------------------------
1397 1397 # Things related to history management
1398 1398 #-------------------------------------------------------------------------
1399 1399
1400 1400 def init_history(self):
1401 1401 """Sets up the command history, and starts regular autosaves."""
1402 1402 self.history_manager = HistoryManager(shell=self, config=self.config)
1403 1403
1404 1404 #-------------------------------------------------------------------------
1405 1405 # Things related to exception handling and tracebacks (not debugging)
1406 1406 #-------------------------------------------------------------------------
1407 1407
1408 1408 def init_traceback_handlers(self, custom_exceptions):
1409 1409 # Syntax error handler.
1410 1410 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1411 1411
1412 1412 # The interactive one is initialized with an offset, meaning we always
1413 1413 # want to remove the topmost item in the traceback, which is our own
1414 1414 # internal code. Valid modes: ['Plain','Context','Verbose']
1415 1415 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1416 1416 color_scheme='NoColor',
1417 1417 tb_offset = 1,
1418 1418 check_cache=self.compile.check_cache)
1419 1419
1420 1420 # The instance will store a pointer to the system-wide exception hook,
1421 1421 # so that runtime code (such as magics) can access it. This is because
1422 1422 # during the read-eval loop, it may get temporarily overwritten.
1423 1423 self.sys_excepthook = sys.excepthook
1424 1424
1425 1425 # and add any custom exception handlers the user may have specified
1426 1426 self.set_custom_exc(*custom_exceptions)
1427 1427
1428 1428 # Set the exception mode
1429 1429 self.InteractiveTB.set_mode(mode=self.xmode)
1430 1430
1431 1431 def set_custom_exc(self, exc_tuple, handler):
1432 1432 """set_custom_exc(exc_tuple,handler)
1433 1433
1434 1434 Set a custom exception handler, which will be called if any of the
1435 1435 exceptions in exc_tuple occur in the mainloop (specifically, in the
1436 1436 run_code() method.
1437 1437
1438 1438 Inputs:
1439 1439
1440 1440 - exc_tuple: a *tuple* of valid exceptions to call the defined
1441 1441 handler for. It is very important that you use a tuple, and NOT A
1442 1442 LIST here, because of the way Python's except statement works. If
1443 1443 you only want to trap a single exception, use a singleton tuple:
1444 1444
1445 1445 exc_tuple == (MyCustomException,)
1446 1446
1447 1447 - handler: this must be defined as a function with the following
1448 1448 basic interface::
1449 1449
1450 1450 def my_handler(self, etype, value, tb, tb_offset=None)
1451 1451 ...
1452 1452 # The return value must be
1453 1453 return structured_traceback
1454 1454
1455 1455 This will be made into an instance method (via types.MethodType)
1456 1456 of IPython itself, and it will be called if any of the exceptions
1457 1457 listed in the exc_tuple are caught. If the handler is None, an
1458 1458 internal basic one is used, which just prints basic info.
1459 1459
1460 1460 WARNING: by putting in your own exception handler into IPython's main
1461 1461 execution loop, you run a very good chance of nasty crashes. This
1462 1462 facility should only be used if you really know what you are doing."""
1463 1463
1464 1464 assert type(exc_tuple)==type(()) , \
1465 1465 "The custom exceptions must be given AS A TUPLE."
1466 1466
1467 1467 def dummy_handler(self,etype,value,tb):
1468 1468 print '*** Simple custom exception handler ***'
1469 1469 print 'Exception type :',etype
1470 1470 print 'Exception value:',value
1471 1471 print 'Traceback :',tb
1472 1472 #print 'Source code :','\n'.join(self.buffer)
1473 1473
1474 1474 if handler is None: handler = dummy_handler
1475 1475
1476 1476 self.CustomTB = types.MethodType(handler,self)
1477 1477 self.custom_exceptions = exc_tuple
1478 1478
1479 1479 def excepthook(self, etype, value, tb):
1480 1480 """One more defense for GUI apps that call sys.excepthook.
1481 1481
1482 1482 GUI frameworks like wxPython trap exceptions and call
1483 1483 sys.excepthook themselves. I guess this is a feature that
1484 1484 enables them to keep running after exceptions that would
1485 1485 otherwise kill their mainloop. This is a bother for IPython
1486 1486 which excepts to catch all of the program exceptions with a try:
1487 1487 except: statement.
1488 1488
1489 1489 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1490 1490 any app directly invokes sys.excepthook, it will look to the user like
1491 1491 IPython crashed. In order to work around this, we can disable the
1492 1492 CrashHandler and replace it with this excepthook instead, which prints a
1493 1493 regular traceback using our InteractiveTB. In this fashion, apps which
1494 1494 call sys.excepthook will generate a regular-looking exception from
1495 1495 IPython, and the CrashHandler will only be triggered by real IPython
1496 1496 crashes.
1497 1497
1498 1498 This hook should be used sparingly, only in places which are not likely
1499 1499 to be true IPython errors.
1500 1500 """
1501 1501 self.showtraceback((etype,value,tb),tb_offset=0)
1502 1502
1503 1503 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1504 1504 exception_only=False):
1505 1505 """Display the exception that just occurred.
1506 1506
1507 1507 If nothing is known about the exception, this is the method which
1508 1508 should be used throughout the code for presenting user tracebacks,
1509 1509 rather than directly invoking the InteractiveTB object.
1510 1510
1511 1511 A specific showsyntaxerror() also exists, but this method can take
1512 1512 care of calling it if needed, so unless you are explicitly catching a
1513 1513 SyntaxError exception, don't try to analyze the stack manually and
1514 1514 simply call this method."""
1515 1515
1516 1516 try:
1517 1517 if exc_tuple is None:
1518 1518 etype, value, tb = sys.exc_info()
1519 1519 else:
1520 1520 etype, value, tb = exc_tuple
1521 1521
1522 1522 if etype is None:
1523 1523 if hasattr(sys, 'last_type'):
1524 1524 etype, value, tb = sys.last_type, sys.last_value, \
1525 1525 sys.last_traceback
1526 1526 else:
1527 1527 self.write_err('No traceback available to show.\n')
1528 1528 return
1529 1529
1530 1530 if etype is SyntaxError:
1531 1531 # Though this won't be called by syntax errors in the input
1532 1532 # line, there may be SyntaxError cases with imported code.
1533 1533 self.showsyntaxerror(filename)
1534 1534 elif etype is UsageError:
1535 1535 print "UsageError:", value
1536 1536 else:
1537 1537 # WARNING: these variables are somewhat deprecated and not
1538 1538 # necessarily safe to use in a threaded environment, but tools
1539 1539 # like pdb depend on their existence, so let's set them. If we
1540 1540 # find problems in the field, we'll need to revisit their use.
1541 1541 sys.last_type = etype
1542 1542 sys.last_value = value
1543 1543 sys.last_traceback = tb
1544 1544 if etype in self.custom_exceptions:
1545 1545 # FIXME: Old custom traceback objects may just return a
1546 1546 # string, in that case we just put it into a list
1547 1547 stb = self.CustomTB(etype, value, tb, tb_offset)
1548 1548 if isinstance(ctb, basestring):
1549 1549 stb = [stb]
1550 1550 else:
1551 1551 if exception_only:
1552 1552 stb = ['An exception has occurred, use %tb to see '
1553 1553 'the full traceback.\n']
1554 1554 stb.extend(self.InteractiveTB.get_exception_only(etype,
1555 1555 value))
1556 1556 else:
1557 1557 stb = self.InteractiveTB.structured_traceback(etype,
1558 1558 value, tb, tb_offset=tb_offset)
1559 1559
1560 1560 if self.call_pdb:
1561 1561 # drop into debugger
1562 1562 self.debugger(force=True)
1563 1563
1564 1564 # Actually show the traceback
1565 1565 self._showtraceback(etype, value, stb)
1566 1566
1567 1567 except KeyboardInterrupt:
1568 1568 self.write_err("\nKeyboardInterrupt\n")
1569 1569
1570 1570 def _showtraceback(self, etype, evalue, stb):
1571 1571 """Actually show a traceback.
1572 1572
1573 1573 Subclasses may override this method to put the traceback on a different
1574 1574 place, like a side channel.
1575 1575 """
1576 1576 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1577 1577
1578 1578 def showsyntaxerror(self, filename=None):
1579 1579 """Display the syntax error that just occurred.
1580 1580
1581 1581 This doesn't display a stack trace because there isn't one.
1582 1582
1583 1583 If a filename is given, it is stuffed in the exception instead
1584 1584 of what was there before (because Python's parser always uses
1585 1585 "<string>" when reading from a string).
1586 1586 """
1587 1587 etype, value, last_traceback = sys.exc_info()
1588 1588
1589 1589 # See note about these variables in showtraceback() above
1590 1590 sys.last_type = etype
1591 1591 sys.last_value = value
1592 1592 sys.last_traceback = last_traceback
1593 1593
1594 1594 if filename and etype is SyntaxError:
1595 1595 # Work hard to stuff the correct filename in the exception
1596 1596 try:
1597 1597 msg, (dummy_filename, lineno, offset, line) = value
1598 1598 except:
1599 1599 # Not the format we expect; leave it alone
1600 1600 pass
1601 1601 else:
1602 1602 # Stuff in the right filename
1603 1603 try:
1604 1604 # Assume SyntaxError is a class exception
1605 1605 value = SyntaxError(msg, (filename, lineno, offset, line))
1606 1606 except:
1607 1607 # If that failed, assume SyntaxError is a string
1608 1608 value = msg, (filename, lineno, offset, line)
1609 1609 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1610 1610 self._showtraceback(etype, value, stb)
1611 1611
1612 1612 # This is overridden in TerminalInteractiveShell to show a message about
1613 1613 # the %paste magic.
1614 1614 def showindentationerror(self):
1615 1615 """Called by run_cell when there's an IndentationError in code entered
1616 1616 at the prompt.
1617 1617
1618 1618 This is overridden in TerminalInteractiveShell to show a message about
1619 1619 the %paste magic."""
1620 1620 self.showsyntaxerror()
1621 1621
1622 1622 #-------------------------------------------------------------------------
1623 1623 # Things related to readline
1624 1624 #-------------------------------------------------------------------------
1625 1625
1626 1626 def init_readline(self):
1627 1627 """Command history completion/saving/reloading."""
1628 1628
1629 1629 if self.readline_use:
1630 1630 import IPython.utils.rlineimpl as readline
1631 1631
1632 1632 self.rl_next_input = None
1633 1633 self.rl_do_indent = False
1634 1634
1635 1635 if not self.readline_use or not readline.have_readline:
1636 1636 self.has_readline = False
1637 1637 self.readline = None
1638 1638 # Set a number of methods that depend on readline to be no-op
1639 1639 self.set_readline_completer = no_op
1640 1640 self.set_custom_completer = no_op
1641 1641 self.set_completer_frame = no_op
1642 1642 warn('Readline services not available or not loaded.')
1643 1643 else:
1644 1644 self.has_readline = True
1645 1645 self.readline = readline
1646 1646 sys.modules['readline'] = readline
1647 1647
1648 1648 # Platform-specific configuration
1649 1649 if os.name == 'nt':
1650 1650 # FIXME - check with Frederick to see if we can harmonize
1651 1651 # naming conventions with pyreadline to avoid this
1652 1652 # platform-dependent check
1653 1653 self.readline_startup_hook = readline.set_pre_input_hook
1654 1654 else:
1655 1655 self.readline_startup_hook = readline.set_startup_hook
1656 1656
1657 1657 # Load user's initrc file (readline config)
1658 1658 # Or if libedit is used, load editrc.
1659 1659 inputrc_name = os.environ.get('INPUTRC')
1660 1660 if inputrc_name is None:
1661 1661 home_dir = get_home_dir()
1662 1662 if home_dir is not None:
1663 1663 inputrc_name = '.inputrc'
1664 1664 if readline.uses_libedit:
1665 1665 inputrc_name = '.editrc'
1666 1666 inputrc_name = os.path.join(home_dir, inputrc_name)
1667 1667 if os.path.isfile(inputrc_name):
1668 1668 try:
1669 1669 readline.read_init_file(inputrc_name)
1670 1670 except:
1671 1671 warn('Problems reading readline initialization file <%s>'
1672 1672 % inputrc_name)
1673 1673
1674 1674 # Configure readline according to user's prefs
1675 1675 # This is only done if GNU readline is being used. If libedit
1676 1676 # is being used (as on Leopard) the readline config is
1677 1677 # not run as the syntax for libedit is different.
1678 1678 if not readline.uses_libedit:
1679 1679 for rlcommand in self.readline_parse_and_bind:
1680 1680 #print "loading rl:",rlcommand # dbg
1681 1681 readline.parse_and_bind(rlcommand)
1682 1682
1683 1683 # Remove some chars from the delimiters list. If we encounter
1684 1684 # unicode chars, discard them.
1685 1685 delims = readline.get_completer_delims()
1686 1686 if not py3compat.PY3:
1687 1687 delims = delims.encode("ascii", "ignore")
1688 1688 for d in self.readline_remove_delims:
1689 1689 delims = delims.replace(d, "")
1690 1690 delims = delims.replace(ESC_MAGIC, '')
1691 1691 readline.set_completer_delims(delims)
1692 1692 # otherwise we end up with a monster history after a while:
1693 1693 readline.set_history_length(self.history_length)
1694 1694
1695 1695 self.refill_readline_hist()
1696 1696 self.readline_no_record = ReadlineNoRecord(self)
1697 1697
1698 1698 # Configure auto-indent for all platforms
1699 1699 self.set_autoindent(self.autoindent)
1700 1700
1701 1701 def refill_readline_hist(self):
1702 1702 # Load the last 1000 lines from history
1703 1703 self.readline.clear_history()
1704 1704 stdin_encoding = sys.stdin.encoding or "utf-8"
1705 1705 for _, _, cell in self.history_manager.get_tail(1000,
1706 1706 include_latest=True):
1707 1707 if cell.strip(): # Ignore blank lines
1708 1708 for line in cell.splitlines():
1709 1709 self.readline.add_history(py3compat.unicode_to_str(line,
1710 1710 stdin_encoding))
1711 1711
1712 1712 def set_next_input(self, s):
1713 1713 """ Sets the 'default' input string for the next command line.
1714 1714
1715 1715 Requires readline.
1716 1716
1717 1717 Example:
1718 1718
1719 1719 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1720 1720 [D:\ipython]|2> Hello Word_ # cursor is here
1721 1721 """
1722 1722 if isinstance(s, unicode):
1723 1723 s = s.encode(self.stdin_encoding, 'replace')
1724 1724 self.rl_next_input = s
1725 1725
1726 1726 # Maybe move this to the terminal subclass?
1727 1727 def pre_readline(self):
1728 1728 """readline hook to be used at the start of each line.
1729 1729
1730 1730 Currently it handles auto-indent only."""
1731 1731
1732 1732 if self.rl_do_indent:
1733 1733 self.readline.insert_text(self._indent_current_str())
1734 1734 if self.rl_next_input is not None:
1735 1735 self.readline.insert_text(self.rl_next_input)
1736 1736 self.rl_next_input = None
1737 1737
1738 1738 def _indent_current_str(self):
1739 1739 """return the current level of indentation as a string"""
1740 1740 return self.input_splitter.indent_spaces * ' '
1741 1741
1742 1742 #-------------------------------------------------------------------------
1743 1743 # Things related to text completion
1744 1744 #-------------------------------------------------------------------------
1745 1745
1746 1746 def init_completer(self):
1747 1747 """Initialize the completion machinery.
1748 1748
1749 1749 This creates completion machinery that can be used by client code,
1750 1750 either interactively in-process (typically triggered by the readline
1751 1751 library), programatically (such as in test suites) or out-of-prcess
1752 1752 (typically over the network by remote frontends).
1753 1753 """
1754 1754 from IPython.core.completer import IPCompleter
1755 1755 from IPython.core.completerlib import (module_completer,
1756 1756 magic_run_completer, cd_completer)
1757 1757
1758 1758 self.Completer = IPCompleter(self,
1759 1759 self.user_ns,
1760 1760 self.user_global_ns,
1761 1761 self.readline_omit__names,
1762 1762 self.alias_manager.alias_table,
1763 1763 self.has_readline)
1764 1764
1765 1765 # Add custom completers to the basic ones built into IPCompleter
1766 1766 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1767 1767 self.strdispatchers['complete_command'] = sdisp
1768 1768 self.Completer.custom_completers = sdisp
1769 1769
1770 1770 self.set_hook('complete_command', module_completer, str_key = 'import')
1771 1771 self.set_hook('complete_command', module_completer, str_key = 'from')
1772 1772 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1773 1773 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1774 1774
1775 1775 # Only configure readline if we truly are using readline. IPython can
1776 1776 # do tab-completion over the network, in GUIs, etc, where readline
1777 1777 # itself may be absent
1778 1778 if self.has_readline:
1779 1779 self.set_readline_completer()
1780 1780
1781 1781 def complete(self, text, line=None, cursor_pos=None):
1782 1782 """Return the completed text and a list of completions.
1783 1783
1784 1784 Parameters
1785 1785 ----------
1786 1786
1787 1787 text : string
1788 1788 A string of text to be completed on. It can be given as empty and
1789 1789 instead a line/position pair are given. In this case, the
1790 1790 completer itself will split the line like readline does.
1791 1791
1792 1792 line : string, optional
1793 1793 The complete line that text is part of.
1794 1794
1795 1795 cursor_pos : int, optional
1796 1796 The position of the cursor on the input line.
1797 1797
1798 1798 Returns
1799 1799 -------
1800 1800 text : string
1801 1801 The actual text that was completed.
1802 1802
1803 1803 matches : list
1804 1804 A sorted list with all possible completions.
1805 1805
1806 1806 The optional arguments allow the completion to take more context into
1807 1807 account, and are part of the low-level completion API.
1808 1808
1809 1809 This is a wrapper around the completion mechanism, similar to what
1810 1810 readline does at the command line when the TAB key is hit. By
1811 1811 exposing it as a method, it can be used by other non-readline
1812 1812 environments (such as GUIs) for text completion.
1813 1813
1814 1814 Simple usage example:
1815 1815
1816 1816 In [1]: x = 'hello'
1817 1817
1818 1818 In [2]: _ip.complete('x.l')
1819 1819 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1820 1820 """
1821 1821
1822 1822 # Inject names into __builtin__ so we can complete on the added names.
1823 1823 with self.builtin_trap:
1824 1824 return self.Completer.complete(text, line, cursor_pos)
1825 1825
1826 1826 def set_custom_completer(self, completer, pos=0):
1827 1827 """Adds a new custom completer function.
1828 1828
1829 1829 The position argument (defaults to 0) is the index in the completers
1830 1830 list where you want the completer to be inserted."""
1831 1831
1832 1832 newcomp = types.MethodType(completer,self.Completer)
1833 1833 self.Completer.matchers.insert(pos,newcomp)
1834 1834
1835 1835 def set_readline_completer(self):
1836 1836 """Reset readline's completer to be our own."""
1837 1837 self.readline.set_completer(self.Completer.rlcomplete)
1838 1838
1839 1839 def set_completer_frame(self, frame=None):
1840 1840 """Set the frame of the completer."""
1841 1841 if frame:
1842 1842 self.Completer.namespace = frame.f_locals
1843 1843 self.Completer.global_namespace = frame.f_globals
1844 1844 else:
1845 1845 self.Completer.namespace = self.user_ns
1846 1846 self.Completer.global_namespace = self.user_global_ns
1847 1847
1848 1848 #-------------------------------------------------------------------------
1849 1849 # Things related to magics
1850 1850 #-------------------------------------------------------------------------
1851 1851
1852 1852 def init_magics(self):
1853 1853 # FIXME: Move the color initialization to the DisplayHook, which
1854 1854 # should be split into a prompt manager and displayhook. We probably
1855 1855 # even need a centralize colors management object.
1856 1856 self.magic_colors(self.colors)
1857 1857 # History was moved to a separate module
1858 1858 from . import history
1859 1859 history.init_ipython(self)
1860 1860
1861 1861 def magic(self, arg_s, next_input=None):
1862 1862 """Call a magic function by name.
1863 1863
1864 1864 Input: a string containing the name of the magic function to call and
1865 1865 any additional arguments to be passed to the magic.
1866 1866
1867 1867 magic('name -opt foo bar') is equivalent to typing at the ipython
1868 1868 prompt:
1869 1869
1870 1870 In[1]: %name -opt foo bar
1871 1871
1872 1872 To call a magic without arguments, simply use magic('name').
1873 1873
1874 1874 This provides a proper Python function to call IPython's magics in any
1875 1875 valid Python code you can type at the interpreter, including loops and
1876 1876 compound statements.
1877 1877 """
1878 1878 # Allow setting the next input - this is used if the user does `a=abs?`.
1879 1879 # We do this first so that magic functions can override it.
1880 1880 if next_input:
1881 1881 self.set_next_input(next_input)
1882 1882
1883 1883 args = arg_s.split(' ',1)
1884 1884 magic_name = args[0]
1885 1885 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1886 1886
1887 1887 try:
1888 1888 magic_args = args[1]
1889 1889 except IndexError:
1890 1890 magic_args = ''
1891 1891 fn = getattr(self,'magic_'+magic_name,None)
1892 1892 if fn is None:
1893 1893 error("Magic function `%s` not found." % magic_name)
1894 1894 else:
1895 1895 magic_args = self.var_expand(magic_args,1)
1896 1896 # Grab local namespace if we need it:
1897 1897 if getattr(fn, "needs_local_scope", False):
1898 1898 self._magic_locals = sys._getframe(1).f_locals
1899 1899 with self.builtin_trap:
1900 1900 result = fn(magic_args)
1901 1901 # Ensure we're not keeping object references around:
1902 1902 self._magic_locals = {}
1903 1903 return result
1904 1904
1905 1905 def define_magic(self, magicname, func):
1906 1906 """Expose own function as magic function for ipython
1907 1907
1908 1908 def foo_impl(self,parameter_s=''):
1909 1909 'My very own magic!. (Use docstrings, IPython reads them).'
1910 1910 print 'Magic function. Passed parameter is between < >:'
1911 1911 print '<%s>' % parameter_s
1912 1912 print 'The self object is:',self
1913 1913
1914 1914 self.define_magic('foo',foo_impl)
1915 1915 """
1916 1916 im = types.MethodType(func,self)
1917 1917 old = getattr(self, "magic_" + magicname, None)
1918 1918 setattr(self, "magic_" + magicname, im)
1919 1919 return old
1920 1920
1921 1921 #-------------------------------------------------------------------------
1922 1922 # Things related to macros
1923 1923 #-------------------------------------------------------------------------
1924 1924
1925 1925 def define_macro(self, name, themacro):
1926 1926 """Define a new macro
1927 1927
1928 1928 Parameters
1929 1929 ----------
1930 1930 name : str
1931 1931 The name of the macro.
1932 1932 themacro : str or Macro
1933 1933 The action to do upon invoking the macro. If a string, a new
1934 1934 Macro object is created by passing the string to it.
1935 1935 """
1936 1936
1937 1937 from IPython.core import macro
1938 1938
1939 1939 if isinstance(themacro, basestring):
1940 1940 themacro = macro.Macro(themacro)
1941 1941 if not isinstance(themacro, macro.Macro):
1942 1942 raise ValueError('A macro must be a string or a Macro instance.')
1943 1943 self.user_ns[name] = themacro
1944 1944
1945 1945 #-------------------------------------------------------------------------
1946 1946 # Things related to the running of system commands
1947 1947 #-------------------------------------------------------------------------
1948 1948
1949 1949 def system_piped(self, cmd):
1950 1950 """Call the given cmd in a subprocess, piping stdout/err
1951 1951
1952 1952 Parameters
1953 1953 ----------
1954 1954 cmd : str
1955 1955 Command to execute (can not end in '&', as background processes are
1956 1956 not supported. Should not be a command that expects input
1957 1957 other than simple text.
1958 1958 """
1959 1959 if cmd.rstrip().endswith('&'):
1960 1960 # this is *far* from a rigorous test
1961 1961 # We do not support backgrounding processes because we either use
1962 1962 # pexpect or pipes to read from. Users can always just call
1963 1963 # os.system() or use ip.system=ip.system_raw
1964 1964 # if they really want a background process.
1965 1965 raise OSError("Background processes not supported.")
1966 1966
1967 1967 # we explicitly do NOT return the subprocess status code, because
1968 1968 # a non-None value would trigger :func:`sys.displayhook` calls.
1969 1969 # Instead, we store the exit_code in user_ns.
1970 1970 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
1971 1971
1972 1972 def system_raw(self, cmd):
1973 1973 """Call the given cmd in a subprocess using os.system
1974 1974
1975 1975 Parameters
1976 1976 ----------
1977 1977 cmd : str
1978 1978 Command to execute.
1979 1979 """
1980 1980 # We explicitly do NOT return the subprocess status code, because
1981 1981 # a non-None value would trigger :func:`sys.displayhook` calls.
1982 1982 # Instead, we store the exit_code in user_ns.
1983 1983 self.user_ns['_exit_code'] = os.system(self.var_expand(cmd, depth=2))
1984 1984
1985 1985 # use piped system by default, because it is better behaved
1986 1986 system = system_piped
1987 1987
1988 1988 def getoutput(self, cmd, split=True):
1989 1989 """Get output (possibly including stderr) from a subprocess.
1990 1990
1991 1991 Parameters
1992 1992 ----------
1993 1993 cmd : str
1994 1994 Command to execute (can not end in '&', as background processes are
1995 1995 not supported.
1996 1996 split : bool, optional
1997 1997
1998 1998 If True, split the output into an IPython SList. Otherwise, an
1999 1999 IPython LSString is returned. These are objects similar to normal
2000 2000 lists and strings, with a few convenience attributes for easier
2001 2001 manipulation of line-based output. You can use '?' on them for
2002 2002 details.
2003 2003 """
2004 2004 if cmd.rstrip().endswith('&'):
2005 2005 # this is *far* from a rigorous test
2006 2006 raise OSError("Background processes not supported.")
2007 2007 out = getoutput(self.var_expand(cmd, depth=2))
2008 2008 if split:
2009 2009 out = SList(out.splitlines())
2010 2010 else:
2011 2011 out = LSString(out)
2012 2012 return out
2013 2013
2014 2014 #-------------------------------------------------------------------------
2015 2015 # Things related to aliases
2016 2016 #-------------------------------------------------------------------------
2017 2017
2018 2018 def init_alias(self):
2019 2019 self.alias_manager = AliasManager(shell=self, config=self.config)
2020 2020 self.ns_table['alias'] = self.alias_manager.alias_table,
2021 2021
2022 2022 #-------------------------------------------------------------------------
2023 2023 # Things related to extensions and plugins
2024 2024 #-------------------------------------------------------------------------
2025 2025
2026 2026 def init_extension_manager(self):
2027 2027 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2028 2028
2029 2029 def init_plugin_manager(self):
2030 2030 self.plugin_manager = PluginManager(config=self.config)
2031 2031
2032 2032 #-------------------------------------------------------------------------
2033 2033 # Things related to payloads
2034 2034 #-------------------------------------------------------------------------
2035 2035
2036 2036 def init_payload(self):
2037 2037 self.payload_manager = PayloadManager(config=self.config)
2038 2038
2039 2039 #-------------------------------------------------------------------------
2040 2040 # Things related to the prefilter
2041 2041 #-------------------------------------------------------------------------
2042 2042
2043 2043 def init_prefilter(self):
2044 2044 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2045 2045 # Ultimately this will be refactored in the new interpreter code, but
2046 2046 # for now, we should expose the main prefilter method (there's legacy
2047 2047 # code out there that may rely on this).
2048 2048 self.prefilter = self.prefilter_manager.prefilter_lines
2049 2049
2050 2050 def auto_rewrite_input(self, cmd):
2051 2051 """Print to the screen the rewritten form of the user's command.
2052 2052
2053 2053 This shows visual feedback by rewriting input lines that cause
2054 2054 automatic calling to kick in, like::
2055 2055
2056 2056 /f x
2057 2057
2058 2058 into::
2059 2059
2060 2060 ------> f(x)
2061 2061
2062 2062 after the user's input prompt. This helps the user understand that the
2063 2063 input line was transformed automatically by IPython.
2064 2064 """
2065 2065 rw = self.displayhook.prompt1.auto_rewrite() + cmd
2066 2066
2067 2067 try:
2068 2068 # plain ascii works better w/ pyreadline, on some machines, so
2069 2069 # we use it and only print uncolored rewrite if we have unicode
2070 2070 rw = str(rw)
2071 2071 print >> io.stdout, rw
2072 2072 except UnicodeEncodeError:
2073 2073 print "------> " + cmd
2074 2074
2075 2075 #-------------------------------------------------------------------------
2076 2076 # Things related to extracting values/expressions from kernel and user_ns
2077 2077 #-------------------------------------------------------------------------
2078 2078
2079 2079 def _simple_error(self):
2080 2080 etype, value = sys.exc_info()[:2]
2081 2081 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2082 2082
2083 2083 def user_variables(self, names):
2084 2084 """Get a list of variable names from the user's namespace.
2085 2085
2086 2086 Parameters
2087 2087 ----------
2088 2088 names : list of strings
2089 2089 A list of names of variables to be read from the user namespace.
2090 2090
2091 2091 Returns
2092 2092 -------
2093 2093 A dict, keyed by the input names and with the repr() of each value.
2094 2094 """
2095 2095 out = {}
2096 2096 user_ns = self.user_ns
2097 2097 for varname in names:
2098 2098 try:
2099 2099 value = repr(user_ns[varname])
2100 2100 except:
2101 2101 value = self._simple_error()
2102 2102 out[varname] = value
2103 2103 return out
2104 2104
2105 2105 def user_expressions(self, expressions):
2106 2106 """Evaluate a dict of expressions in the user's namespace.
2107 2107
2108 2108 Parameters
2109 2109 ----------
2110 2110 expressions : dict
2111 2111 A dict with string keys and string values. The expression values
2112 2112 should be valid Python expressions, each of which will be evaluated
2113 2113 in the user namespace.
2114 2114
2115 2115 Returns
2116 2116 -------
2117 2117 A dict, keyed like the input expressions dict, with the repr() of each
2118 2118 value.
2119 2119 """
2120 2120 out = {}
2121 2121 user_ns = self.user_ns
2122 2122 global_ns = self.user_global_ns
2123 2123 for key, expr in expressions.iteritems():
2124 2124 try:
2125 2125 value = repr(eval(expr, global_ns, user_ns))
2126 2126 except:
2127 2127 value = self._simple_error()
2128 2128 out[key] = value
2129 2129 return out
2130 2130
2131 2131 #-------------------------------------------------------------------------
2132 2132 # Things related to the running of code
2133 2133 #-------------------------------------------------------------------------
2134 2134
2135 2135 def ex(self, cmd):
2136 2136 """Execute a normal python statement in user namespace."""
2137 2137 with self.builtin_trap:
2138 2138 exec cmd in self.user_global_ns, self.user_ns
2139 2139
2140 2140 def ev(self, expr):
2141 2141 """Evaluate python expression expr in user namespace.
2142 2142
2143 2143 Returns the result of evaluation
2144 2144 """
2145 2145 with self.builtin_trap:
2146 2146 return eval(expr, self.user_global_ns, self.user_ns)
2147 2147
2148 2148 def safe_execfile(self, fname, *where, **kw):
2149 2149 """A safe version of the builtin execfile().
2150 2150
2151 2151 This version will never throw an exception, but instead print
2152 2152 helpful error messages to the screen. This only works on pure
2153 2153 Python files with the .py extension.
2154 2154
2155 2155 Parameters
2156 2156 ----------
2157 2157 fname : string
2158 2158 The name of the file to be executed.
2159 2159 where : tuple
2160 2160 One or two namespaces, passed to execfile() as (globals,locals).
2161 2161 If only one is given, it is passed as both.
2162 2162 exit_ignore : bool (False)
2163 2163 If True, then silence SystemExit for non-zero status (it is always
2164 2164 silenced for zero status, as it is so common).
2165 2165 """
2166 2166 kw.setdefault('exit_ignore', False)
2167 2167
2168 2168 fname = os.path.abspath(os.path.expanduser(fname))
2169 2169
2170 2170 # Make sure we can open the file
2171 2171 try:
2172 2172 with open(fname) as thefile:
2173 2173 pass
2174 2174 except:
2175 2175 warn('Could not open file <%s> for safe execution.' % fname)
2176 2176 return
2177 2177
2178 2178 # Find things also in current directory. This is needed to mimic the
2179 2179 # behavior of running a script from the system command line, where
2180 2180 # Python inserts the script's directory into sys.path
2181 2181 dname = os.path.dirname(fname)
2182 2182
2183 2183 with prepended_to_syspath(dname):
2184 2184 try:
2185 2185 py3compat.execfile(fname,*where)
2186 2186 except SystemExit, status:
2187 2187 # If the call was made with 0 or None exit status (sys.exit(0)
2188 2188 # or sys.exit() ), don't bother showing a traceback, as both of
2189 2189 # these are considered normal by the OS:
2190 2190 # > python -c'import sys;sys.exit(0)'; echo $?
2191 2191 # 0
2192 2192 # > python -c'import sys;sys.exit()'; echo $?
2193 2193 # 0
2194 2194 # For other exit status, we show the exception unless
2195 2195 # explicitly silenced, but only in short form.
2196 2196 if status.code not in (0, None) and not kw['exit_ignore']:
2197 2197 self.showtraceback(exception_only=True)
2198 2198 except:
2199 2199 self.showtraceback()
2200 2200
2201 2201 def safe_execfile_ipy(self, fname):
2202 2202 """Like safe_execfile, but for .ipy files with IPython syntax.
2203 2203
2204 2204 Parameters
2205 2205 ----------
2206 2206 fname : str
2207 2207 The name of the file to execute. The filename must have a
2208 2208 .ipy extension.
2209 2209 """
2210 2210 fname = os.path.abspath(os.path.expanduser(fname))
2211 2211
2212 2212 # Make sure we can open the file
2213 2213 try:
2214 2214 with open(fname) as thefile:
2215 2215 pass
2216 2216 except:
2217 2217 warn('Could not open file <%s> for safe execution.' % fname)
2218 2218 return
2219 2219
2220 2220 # Find things also in current directory. This is needed to mimic the
2221 2221 # behavior of running a script from the system command line, where
2222 2222 # Python inserts the script's directory into sys.path
2223 2223 dname = os.path.dirname(fname)
2224 2224
2225 2225 with prepended_to_syspath(dname):
2226 2226 try:
2227 2227 with open(fname) as thefile:
2228 2228 # self.run_cell currently captures all exceptions
2229 2229 # raised in user code. It would be nice if there were
2230 2230 # versions of runlines, execfile that did raise, so
2231 2231 # we could catch the errors.
2232 2232 self.run_cell(thefile.read(), store_history=False)
2233 2233 except:
2234 2234 self.showtraceback()
2235 2235 warn('Unknown failure executing file: <%s>' % fname)
2236 2236
2237 2237 def run_cell(self, raw_cell, store_history=True):
2238 2238 """Run a complete IPython cell.
2239 2239
2240 2240 Parameters
2241 2241 ----------
2242 2242 raw_cell : str
2243 2243 The code (including IPython code such as %magic functions) to run.
2244 2244 store_history : bool
2245 2245 If True, the raw and translated cell will be stored in IPython's
2246 2246 history. For user code calling back into IPython's machinery, this
2247 2247 should be set to False.
2248 2248 """
2249 2249 if (not raw_cell) or raw_cell.isspace():
2250 2250 return
2251 2251
2252 2252 for line in raw_cell.splitlines():
2253 2253 self.input_splitter.push(line)
2254 2254 cell = self.input_splitter.source_reset()
2255 2255
2256 2256 with self.builtin_trap:
2257 2257 prefilter_failed = False
2258 2258 if len(cell.splitlines()) == 1:
2259 2259 try:
2260 2260 # use prefilter_lines to handle trailing newlines
2261 2261 # restore trailing newline for ast.parse
2262 2262 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2263 2263 except AliasError as e:
2264 2264 error(e)
2265 2265 prefilter_failed = True
2266 2266 except Exception:
2267 2267 # don't allow prefilter errors to crash IPython
2268 2268 self.showtraceback()
2269 2269 prefilter_failed = True
2270 2270
2271 2271 # Store raw and processed history
2272 2272 if store_history:
2273 2273 self.history_manager.store_inputs(self.execution_count,
2274 2274 cell, raw_cell)
2275 2275
2276 2276 self.logger.log(cell, raw_cell)
2277 2277
2278 2278 if not prefilter_failed:
2279 2279 # don't run if prefilter failed
2280 2280 cell_name = self.compile.cache(cell, self.execution_count)
2281 2281
2282 2282 with self.display_trap:
2283 2283 try:
2284 code_ast = ast.parse(cell, filename=cell_name)
2284 code_ast = self.compile.ast_parse(cell, filename=cell_name)
2285 2285 except IndentationError:
2286 2286 self.showindentationerror()
2287 2287 self.execution_count += 1
2288 2288 return None
2289 2289 except (OverflowError, SyntaxError, ValueError, TypeError,
2290 2290 MemoryError):
2291 2291 self.showsyntaxerror()
2292 2292 self.execution_count += 1
2293 2293 return None
2294 2294
2295 2295 self.run_ast_nodes(code_ast.body, cell_name,
2296 2296 interactivity="last_expr")
2297 2297
2298 2298 # Execute any registered post-execution functions.
2299 2299 for func, status in self._post_execute.iteritems():
2300 2300 if not status:
2301 2301 continue
2302 2302 try:
2303 2303 func()
2304 2304 except:
2305 2305 self.showtraceback()
2306 2306 # Deactivate failing function
2307 2307 self._post_execute[func] = False
2308 2308
2309 2309 if store_history:
2310 2310 # Write output to the database. Does nothing unless
2311 2311 # history output logging is enabled.
2312 2312 self.history_manager.store_output(self.execution_count)
2313 2313 # Each cell is a *single* input, regardless of how many lines it has
2314 2314 self.execution_count += 1
2315 2315
2316 2316 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2317 2317 """Run a sequence of AST nodes. The execution mode depends on the
2318 2318 interactivity parameter.
2319 2319
2320 2320 Parameters
2321 2321 ----------
2322 2322 nodelist : list
2323 2323 A sequence of AST nodes to run.
2324 2324 cell_name : str
2325 2325 Will be passed to the compiler as the filename of the cell. Typically
2326 2326 the value returned by ip.compile.cache(cell).
2327 2327 interactivity : str
2328 2328 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2329 2329 run interactively (displaying output from expressions). 'last_expr'
2330 2330 will run the last node interactively only if it is an expression (i.e.
2331 2331 expressions in loops or other blocks are not displayed. Other values
2332 2332 for this parameter will raise a ValueError.
2333 2333 """
2334 2334 if not nodelist:
2335 2335 return
2336 2336
2337 2337 if interactivity == 'last_expr':
2338 2338 if isinstance(nodelist[-1], ast.Expr):
2339 2339 interactivity = "last"
2340 2340 else:
2341 2341 interactivity = "none"
2342 2342
2343 2343 if interactivity == 'none':
2344 2344 to_run_exec, to_run_interactive = nodelist, []
2345 2345 elif interactivity == 'last':
2346 2346 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2347 2347 elif interactivity == 'all':
2348 2348 to_run_exec, to_run_interactive = [], nodelist
2349 2349 else:
2350 2350 raise ValueError("Interactivity was %r" % interactivity)
2351 2351
2352 2352 exec_count = self.execution_count
2353 2353
2354 2354 try:
2355 2355 for i, node in enumerate(to_run_exec):
2356 2356 mod = ast.Module([node])
2357 2357 code = self.compile(mod, cell_name, "exec")
2358 2358 if self.run_code(code):
2359 2359 return True
2360 2360
2361 2361 for i, node in enumerate(to_run_interactive):
2362 2362 mod = ast.Interactive([node])
2363 2363 code = self.compile(mod, cell_name, "single")
2364 2364 if self.run_code(code):
2365 2365 return True
2366 2366 except:
2367 2367 # It's possible to have exceptions raised here, typically by
2368 2368 # compilation of odd code (such as a naked 'return' outside a
2369 2369 # function) that did parse but isn't valid. Typically the exception
2370 2370 # is a SyntaxError, but it's safest just to catch anything and show
2371 2371 # the user a traceback.
2372 2372
2373 2373 # We do only one try/except outside the loop to minimize the impact
2374 2374 # on runtime, and also because if any node in the node list is
2375 2375 # broken, we should stop execution completely.
2376 2376 self.showtraceback()
2377 2377
2378 2378 return False
2379 2379
2380 2380 def run_code(self, code_obj):
2381 2381 """Execute a code object.
2382 2382
2383 2383 When an exception occurs, self.showtraceback() is called to display a
2384 2384 traceback.
2385 2385
2386 2386 Parameters
2387 2387 ----------
2388 2388 code_obj : code object
2389 2389 A compiled code object, to be executed
2390 2390 post_execute : bool [default: True]
2391 2391 whether to call post_execute hooks after this particular execution.
2392 2392
2393 2393 Returns
2394 2394 -------
2395 2395 False : successful execution.
2396 2396 True : an error occurred.
2397 2397 """
2398 2398
2399 2399 # Set our own excepthook in case the user code tries to call it
2400 2400 # directly, so that the IPython crash handler doesn't get triggered
2401 2401 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2402 2402
2403 2403 # we save the original sys.excepthook in the instance, in case config
2404 2404 # code (such as magics) needs access to it.
2405 2405 self.sys_excepthook = old_excepthook
2406 2406 outflag = 1 # happens in more places, so it's easier as default
2407 2407 try:
2408 2408 try:
2409 2409 self.hooks.pre_run_code_hook()
2410 2410 #rprint('Running code', repr(code_obj)) # dbg
2411 2411 exec code_obj in self.user_global_ns, self.user_ns
2412 2412 finally:
2413 2413 # Reset our crash handler in place
2414 2414 sys.excepthook = old_excepthook
2415 2415 except SystemExit:
2416 2416 self.showtraceback(exception_only=True)
2417 2417 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2418 2418 except self.custom_exceptions:
2419 2419 etype,value,tb = sys.exc_info()
2420 2420 self.CustomTB(etype,value,tb)
2421 2421 except:
2422 2422 self.showtraceback()
2423 2423 else:
2424 2424 outflag = 0
2425 2425 if softspace(sys.stdout, 0):
2426 2426 print
2427 2427
2428 2428 return outflag
2429 2429
2430 2430 # For backwards compatibility
2431 2431 runcode = run_code
2432 2432
2433 2433 #-------------------------------------------------------------------------
2434 2434 # Things related to GUI support and pylab
2435 2435 #-------------------------------------------------------------------------
2436 2436
2437 2437 def enable_pylab(self, gui=None, import_all=True):
2438 2438 raise NotImplementedError('Implement enable_pylab in a subclass')
2439 2439
2440 2440 #-------------------------------------------------------------------------
2441 2441 # Utilities
2442 2442 #-------------------------------------------------------------------------
2443 2443
2444 2444 def var_expand(self,cmd,depth=0):
2445 2445 """Expand python variables in a string.
2446 2446
2447 2447 The depth argument indicates how many frames above the caller should
2448 2448 be walked to look for the local namespace where to expand variables.
2449 2449
2450 2450 The global namespace for expansion is always the user's interactive
2451 2451 namespace.
2452 2452 """
2453 2453 res = ItplNS(cmd, self.user_ns, # globals
2454 2454 # Skip our own frame in searching for locals:
2455 2455 sys._getframe(depth+1).f_locals # locals
2456 2456 )
2457 2457 return py3compat.str_to_unicode(str(res), res.codec)
2458 2458
2459 2459 def mktempfile(self, data=None, prefix='ipython_edit_'):
2460 2460 """Make a new tempfile and return its filename.
2461 2461
2462 2462 This makes a call to tempfile.mktemp, but it registers the created
2463 2463 filename internally so ipython cleans it up at exit time.
2464 2464
2465 2465 Optional inputs:
2466 2466
2467 2467 - data(None): if data is given, it gets written out to the temp file
2468 2468 immediately, and the file is closed again."""
2469 2469
2470 2470 filename = tempfile.mktemp('.py', prefix)
2471 2471 self.tempfiles.append(filename)
2472 2472
2473 2473 if data:
2474 2474 tmp_file = open(filename,'w')
2475 2475 tmp_file.write(data)
2476 2476 tmp_file.close()
2477 2477 return filename
2478 2478
2479 2479 # TODO: This should be removed when Term is refactored.
2480 2480 def write(self,data):
2481 2481 """Write a string to the default output"""
2482 2482 io.stdout.write(data)
2483 2483
2484 2484 # TODO: This should be removed when Term is refactored.
2485 2485 def write_err(self,data):
2486 2486 """Write a string to the default error output"""
2487 2487 io.stderr.write(data)
2488 2488
2489 2489 def ask_yes_no(self,prompt,default=True):
2490 2490 if self.quiet:
2491 2491 return True
2492 2492 return ask_yes_no(prompt,default)
2493 2493
2494 2494 def show_usage(self):
2495 2495 """Show a usage message"""
2496 2496 page.page(IPython.core.usage.interactive_usage)
2497 2497
2498 2498 def find_user_code(self, target, raw=True):
2499 2499 """Get a code string from history, file, or a string or macro.
2500 2500
2501 2501 This is mainly used by magic functions.
2502 2502
2503 2503 Parameters
2504 2504 ----------
2505 2505 target : str
2506 2506 A string specifying code to retrieve. This will be tried respectively
2507 2507 as: ranges of input history (see %history for syntax), a filename, or
2508 2508 an expression evaluating to a string or Macro in the user namespace.
2509 2509 raw : bool
2510 2510 If true (default), retrieve raw history. Has no effect on the other
2511 2511 retrieval mechanisms.
2512 2512
2513 2513 Returns
2514 2514 -------
2515 2515 A string of code.
2516 2516
2517 2517 ValueError is raised if nothing is found, and TypeError if it evaluates
2518 2518 to an object of another type. In each case, .args[0] is a printable
2519 2519 message.
2520 2520 """
2521 2521 code = self.extract_input_lines(target, raw=raw) # Grab history
2522 2522 if code:
2523 2523 return code
2524 2524 if os.path.isfile(target): # Read file
2525 2525 return open(target, "r").read()
2526 2526
2527 2527 try: # User namespace
2528 2528 codeobj = eval(target, self.user_ns)
2529 2529 except Exception:
2530 2530 raise ValueError(("'%s' was not found in history, as a file, nor in"
2531 2531 " the user namespace.") % target)
2532 2532 if isinstance(codeobj, basestring):
2533 2533 return codeobj
2534 2534 elif isinstance(codeobj, Macro):
2535 2535 return codeobj.value
2536 2536
2537 2537 raise TypeError("%s is neither a string nor a macro." % target,
2538 2538 codeobj)
2539 2539
2540 2540 #-------------------------------------------------------------------------
2541 2541 # Things related to IPython exiting
2542 2542 #-------------------------------------------------------------------------
2543 2543 def atexit_operations(self):
2544 2544 """This will be executed at the time of exit.
2545 2545
2546 2546 Cleanup operations and saving of persistent data that is done
2547 2547 unconditionally by IPython should be performed here.
2548 2548
2549 2549 For things that may depend on startup flags or platform specifics (such
2550 2550 as having readline or not), register a separate atexit function in the
2551 2551 code that has the appropriate information, rather than trying to
2552 2552 clutter
2553 2553 """
2554 2554 # Close the history session (this stores the end time and line count)
2555 2555 # this must be *before* the tempfile cleanup, in case of temporary
2556 2556 # history db
2557 2557 self.history_manager.end_session()
2558 2558
2559 2559 # Cleanup all tempfiles left around
2560 2560 for tfile in self.tempfiles:
2561 2561 try:
2562 2562 os.unlink(tfile)
2563 2563 except OSError:
2564 2564 pass
2565 2565
2566 2566 # Clear all user namespaces to release all references cleanly.
2567 2567 self.reset(new_session=False)
2568 2568
2569 2569 # Run user hooks
2570 2570 self.hooks.shutdown_hook()
2571 2571
2572 2572 def cleanup(self):
2573 2573 self.restore_sys_module_state()
2574 2574
2575 2575
2576 2576 class InteractiveShellABC(object):
2577 2577 """An abstract base class for InteractiveShell."""
2578 2578 __metaclass__ = abc.ABCMeta
2579 2579
2580 2580 InteractiveShellABC.register(InteractiveShell)
@@ -1,124 +1,135 b''
1 1 """Tests for the key interactiveshell module.
2 2
3 3 Historically the main classes in interactiveshell have been under-tested. This
4 4 module should grow as many single-method tests as possible to trap many of the
5 5 recurring bugs we seem to encounter with high-level interaction.
6 6
7 7 Authors
8 8 -------
9 9 * Fernando Perez
10 10 """
11 11 #-----------------------------------------------------------------------------
12 12 # Copyright (C) 2011 The IPython Development Team
13 13 #
14 14 # Distributed under the terms of the BSD License. The full license is in
15 15 # the file COPYING, distributed as part of this software.
16 16 #-----------------------------------------------------------------------------
17 17
18 18 #-----------------------------------------------------------------------------
19 19 # Imports
20 20 #-----------------------------------------------------------------------------
21 21 # stdlib
22 22 import unittest
23 23 from StringIO import StringIO
24 24
25 25 from IPython.testing import decorators as dec
26 26 from IPython.utils import io
27 27
28 28 #-----------------------------------------------------------------------------
29 29 # Tests
30 30 #-----------------------------------------------------------------------------
31 31
32 32 class InteractiveShellTestCase(unittest.TestCase):
33 33 def test_naked_string_cells(self):
34 34 """Test that cells with only naked strings are fully executed"""
35 35 ip = get_ipython()
36 36 # First, single-line inputs
37 37 ip.run_cell('"a"\n')
38 38 self.assertEquals(ip.user_ns['_'], 'a')
39 39 # And also multi-line cells
40 40 ip.run_cell('"""a\nb"""\n')
41 41 self.assertEquals(ip.user_ns['_'], 'a\nb')
42 42
43 43 def test_run_empty_cell(self):
44 44 """Just make sure we don't get a horrible error with a blank
45 45 cell of input. Yes, I did overlook that."""
46 46 ip = get_ipython()
47 47 old_xc = ip.execution_count
48 48 ip.run_cell('')
49 49 self.assertEquals(ip.execution_count, old_xc)
50 50
51 51 def test_run_cell_multiline(self):
52 52 """Multi-block, multi-line cells must execute correctly.
53 53 """
54 54 ip = get_ipython()
55 55 src = '\n'.join(["x=1",
56 56 "y=2",
57 57 "if 1:",
58 58 " x += 1",
59 59 " y += 1",])
60 60 ip.run_cell(src)
61 61 self.assertEquals(ip.user_ns['x'], 2)
62 62 self.assertEquals(ip.user_ns['y'], 3)
63 63
64 64 def test_multiline_string_cells(self):
65 65 "Code sprinkled with multiline strings should execute (GH-306)"
66 66 ip = get_ipython()
67 67 ip.run_cell('tmp=0')
68 68 self.assertEquals(ip.user_ns['tmp'], 0)
69 69 ip.run_cell('tmp=1;"""a\nb"""\n')
70 70 self.assertEquals(ip.user_ns['tmp'], 1)
71 71
72 72 def test_dont_cache_with_semicolon(self):
73 73 "Ending a line with semicolon should not cache the returned object (GH-307)"
74 74 ip = get_ipython()
75 75 oldlen = len(ip.user_ns['Out'])
76 76 a = ip.run_cell('1;')
77 77 newlen = len(ip.user_ns['Out'])
78 78 self.assertEquals(oldlen, newlen)
79 79 #also test the default caching behavior
80 80 ip.run_cell('1')
81 81 newlen = len(ip.user_ns['Out'])
82 82 self.assertEquals(oldlen+1, newlen)
83 83
84 84 def test_In_variable(self):
85 85 "Verify that In variable grows with user input (GH-284)"
86 86 ip = get_ipython()
87 87 oldlen = len(ip.user_ns['In'])
88 88 ip.run_cell('1;')
89 89 newlen = len(ip.user_ns['In'])
90 90 self.assertEquals(oldlen+1, newlen)
91 91 self.assertEquals(ip.user_ns['In'][-1],'1;')
92 92
93 93 def test_magic_names_in_string(self):
94 94 ip = get_ipython()
95 95 ip.run_cell('a = """\n%exit\n"""')
96 96 self.assertEquals(ip.user_ns['a'], '\n%exit\n')
97 97
98 98 def test_alias_crash(self):
99 99 """Errors in prefilter can't crash IPython"""
100 100 ip = get_ipython()
101 101 ip.run_cell('%alias parts echo first %s second %s')
102 102 # capture stderr:
103 103 save_err = io.stderr
104 104 io.stderr = StringIO()
105 105 ip.run_cell('parts 1')
106 106 err = io.stderr.getvalue()
107 107 io.stderr = save_err
108 108 self.assertEquals(err.split(':')[0], 'ERROR')
109 109
110 110 def test_trailing_newline(self):
111 111 """test that running !(command) does not raise a SyntaxError"""
112 112 ip = get_ipython()
113 113 ip.run_cell('!(true)\n', False)
114 114 ip.run_cell('!(true)\n\n\n', False)
115 115
116 116 def test_gh_597(self):
117 117 """Pretty-printing lists of objects with non-ascii reprs may cause
118 118 problems."""
119 119 class Spam(object):
120 120 def __repr__(self):
121 121 return "\xe9"*50
122 122 import IPython.core.formatters
123 123 f = IPython.core.formatters.PlainTextFormatter()
124 124 f([Spam(),Spam()])
125
126 def test_future_flags(self):
127 """Check that future flags are used for parsing code (gh-777)"""
128 ip = get_ipython()
129 ip.run_cell('from __future__ import print_function')
130 try:
131 ip.run_cell('prfunc_return_val = print(1,2, sep=" ")')
132 assert 'prfunc_return_val' in ip.user_ns
133 finally:
134 # Reset compiler flags so we don't mess up other tests.
135 ip.compile.reset_compiler_flags()
General Comments 0
You need to be logged in to leave comments. Login now