##// END OF EJS Templates
add script magics...
MinRK -
Show More
@@ -0,0 +1,155 b''
1 """Magic functions for running cells in various scripts."""
2 #-----------------------------------------------------------------------------
3 # Copyright (c) 2012 The IPython Development Team.
4 #
5 # Distributed under the terms of the Modified BSD License.
6 #
7 # The full license is in the file COPYING.txt, distributed with this software.
8 #-----------------------------------------------------------------------------
9
10 #-----------------------------------------------------------------------------
11 # Imports
12 #-----------------------------------------------------------------------------
13
14 # Stdlib
15 import os
16 import re
17 import sys
18 from subprocess import Popen, PIPE
19
20 # Our own packages
21 from IPython.config.configurable import Configurable
22 from IPython.core.error import UsageError
23 from IPython.core.magic import (
24 Magics, magics_class, line_magic, cell_magic
25 )
26 from IPython.testing.skipdoctest import skip_doctest
27 from IPython.utils.process import find_cmd, FindCmdError
28 from IPython.utils.traitlets import List, Dict
29
30 #-----------------------------------------------------------------------------
31 # Magic implementation classes
32 #-----------------------------------------------------------------------------
33
34 @magics_class
35 class ScriptMagics(Magics, Configurable):
36 """Magics for talking to scripts
37
38 This defines a base `%%script` cell magic for running a cell
39 with a program in a subprocess, and registers a few top-level
40 magics that call %%script with common interpreters.
41 """
42 script_magics = List(config=True,
43 help="""Extra script cell magics to define
44
45 This generates simple wrappers of `%%script foo` as `%%foo`.
46
47 If you want to add script magics that aren't on your path,
48 specify them in script_paths
49 """,
50 )
51 def _script_magics_default(self):
52 """default to a common list of programs if we find them"""
53
54 defaults = []
55 to_try = []
56 if os.name == 'nt':
57 defaults.append('cmd')
58 to_try.append('powershell')
59 to_try.extend([
60 'sh',
61 'bash',
62 'perl',
63 'ruby',
64 'python3',
65 'pypy',
66 ])
67
68 for cmd in to_try:
69 if cmd in self.script_paths:
70 defaults.append(cmd)
71 else:
72 try:
73 find_cmd(cmd)
74 except FindCmdError:
75 # command not found, ignore it
76 pass
77 except ImportError:
78 # Windows without pywin32, find_cmd doesn't work
79 pass
80 else:
81 defaults.append(cmd)
82 return defaults
83
84 script_paths = Dict(config=True,
85 help="""Dict mapping short 'ruby' names to full paths, such as '/opt/secret/bin/ruby'
86
87 Only necessary for items in script_magics where the default path will not
88 find the right interpreter.
89 """
90 )
91
92 def __init__(self, shell=None):
93 Configurable.__init__(self, config=shell.config)
94 self._generate_script_magics()
95 Magics.__init__(self, shell=shell)
96
97 def _generate_script_magics(self):
98 cell_magics = self.magics['cell']
99 for name in self.script_magics:
100 cell_magics[name] = self._make_script_magic(name)
101
102 def _make_script_magic(self, name):
103 """make a named magic, that calls %%script with a particular program"""
104 # expand to explicit path if necessary:
105 script = self.script_paths.get(name, name)
106
107 def named_script_magic(line, cell):
108 # if line, add it as cl-flags
109 if line:
110 line = "%s %s" % (script, line)
111 else:
112 line = script
113 return self.shebang(line, cell)
114
115 # write a basic docstring:
116 named_script_magic.__doc__ = \
117 """%%{name} script magic
118
119 Run cells with {script} in a subprocess.
120
121 This is a shortcut for `%%script {script}`
122 """.format(**locals())
123
124 return named_script_magic
125
126 @cell_magic("script")
127 def shebang(self, line, cell):
128 """Run a cell via a shell command
129
130 The `%%script` line is like the #! line of script,
131 specifying a program (bash, perl, ruby, etc.) with which to run.
132
133 The rest of the cell is run by that program.
134
135 Examples
136 --------
137 ::
138
139 In [1]: %%script bash
140 ...: for i in 1 2 3; do
141 ...: echo $i
142 ...: done
143 1
144 2
145 3
146 """
147 p = Popen(line, stdout=PIPE, stderr=PIPE, stdin=PIPE)
148 out,err = p.communicate(cell)
149 sys.stdout.write(out)
150 sys.stdout.flush()
151 sys.stderr.write(err)
152 sys.stderr.flush()
153
154 # expose %%script as %%!
155 cell_magic('!')(shebang)
@@ -1,2976 +1,2977 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 os
26 26 import re
27 27 import runpy
28 28 import sys
29 29 import tempfile
30 30 import types
31 31
32 32 # We need to use nested to support python 2.6, once we move to >=2.7, we can
33 33 # use the with keyword's new builtin support for nested managers
34 34 try:
35 35 from contextlib import nested
36 36 except:
37 37 from IPython.utils.nested_context import nested
38 38
39 39 from IPython.config.configurable import SingletonConfigurable
40 40 from IPython.core import debugger, oinspect
41 41 from IPython.core import history as ipcorehist
42 42 from IPython.core import magic
43 43 from IPython.core import page
44 44 from IPython.core import prefilter
45 45 from IPython.core import shadowns
46 46 from IPython.core import ultratb
47 47 from IPython.core.alias import AliasManager, AliasError
48 48 from IPython.core.autocall import ExitAutocall
49 49 from IPython.core.builtin_trap import BuiltinTrap
50 50 from IPython.core.compilerop import CachingCompiler
51 51 from IPython.core.display_trap import DisplayTrap
52 52 from IPython.core.displayhook import DisplayHook
53 53 from IPython.core.displaypub import DisplayPublisher
54 54 from IPython.core.error import UsageError
55 55 from IPython.core.extensions import ExtensionManager
56 56 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
57 57 from IPython.core.formatters import DisplayFormatter
58 58 from IPython.core.history import HistoryManager
59 59 from IPython.core.inputsplitter import IPythonInputSplitter
60 60 from IPython.core.logger import Logger
61 61 from IPython.core.macro import Macro
62 62 from IPython.core.payload import PayloadManager
63 63 from IPython.core.plugin import PluginManager
64 64 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
65 65 from IPython.core.profiledir import ProfileDir
66 66 from IPython.core.pylabtools import pylab_activate
67 67 from IPython.core.prompts import PromptManager
68 68 from IPython.utils import PyColorize
69 69 from IPython.utils import io
70 70 from IPython.utils import py3compat
71 71 from IPython.utils import openpy
72 72 from IPython.utils.doctestreload import doctest_reload
73 73 from IPython.utils.io import ask_yes_no
74 74 from IPython.utils.ipstruct import Struct
75 75 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename
76 76 from IPython.utils.pickleshare import PickleShareDB
77 77 from IPython.utils.process import system, getoutput
78 78 from IPython.utils.strdispatch import StrDispatch
79 79 from IPython.utils.syspathcontext import prepended_to_syspath
80 80 from IPython.utils.text import (format_screen, LSString, SList,
81 81 DollarFormatter)
82 82 from IPython.utils.traitlets import (Integer, CBool, CaselessStrEnum, Enum,
83 83 List, Unicode, Instance, Type)
84 84 from IPython.utils.warn import warn, error
85 85 import IPython.core.hooks
86 86
87 87 #-----------------------------------------------------------------------------
88 88 # Globals
89 89 #-----------------------------------------------------------------------------
90 90
91 91 # compiled regexps for autoindent management
92 92 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
93 93
94 94 #-----------------------------------------------------------------------------
95 95 # Utilities
96 96 #-----------------------------------------------------------------------------
97 97
98 98 def softspace(file, newvalue):
99 99 """Copied from code.py, to remove the dependency"""
100 100
101 101 oldvalue = 0
102 102 try:
103 103 oldvalue = file.softspace
104 104 except AttributeError:
105 105 pass
106 106 try:
107 107 file.softspace = newvalue
108 108 except (AttributeError, TypeError):
109 109 # "attribute-less object" or "read-only attributes"
110 110 pass
111 111 return oldvalue
112 112
113 113
114 114 def no_op(*a, **kw): pass
115 115
116 116 class NoOpContext(object):
117 117 def __enter__(self): pass
118 118 def __exit__(self, type, value, traceback): pass
119 119 no_op_context = NoOpContext()
120 120
121 121 class SpaceInInput(Exception): pass
122 122
123 123 class Bunch: pass
124 124
125 125
126 126 def get_default_colors():
127 127 if sys.platform=='darwin':
128 128 return "LightBG"
129 129 elif os.name=='nt':
130 130 return 'Linux'
131 131 else:
132 132 return 'Linux'
133 133
134 134
135 135 class SeparateUnicode(Unicode):
136 136 """A Unicode subclass to validate separate_in, separate_out, etc.
137 137
138 138 This is a Unicode based trait that converts '0'->'' and '\\n'->'\n'.
139 139 """
140 140
141 141 def validate(self, obj, value):
142 142 if value == '0': value = ''
143 143 value = value.replace('\\n','\n')
144 144 return super(SeparateUnicode, self).validate(obj, value)
145 145
146 146
147 147 class ReadlineNoRecord(object):
148 148 """Context manager to execute some code, then reload readline history
149 149 so that interactive input to the code doesn't appear when pressing up."""
150 150 def __init__(self, shell):
151 151 self.shell = shell
152 152 self._nested_level = 0
153 153
154 154 def __enter__(self):
155 155 if self._nested_level == 0:
156 156 try:
157 157 self.orig_length = self.current_length()
158 158 self.readline_tail = self.get_readline_tail()
159 159 except (AttributeError, IndexError): # Can fail with pyreadline
160 160 self.orig_length, self.readline_tail = 999999, []
161 161 self._nested_level += 1
162 162
163 163 def __exit__(self, type, value, traceback):
164 164 self._nested_level -= 1
165 165 if self._nested_level == 0:
166 166 # Try clipping the end if it's got longer
167 167 try:
168 168 e = self.current_length() - self.orig_length
169 169 if e > 0:
170 170 for _ in range(e):
171 171 self.shell.readline.remove_history_item(self.orig_length)
172 172
173 173 # If it still doesn't match, just reload readline history.
174 174 if self.current_length() != self.orig_length \
175 175 or self.get_readline_tail() != self.readline_tail:
176 176 self.shell.refill_readline_hist()
177 177 except (AttributeError, IndexError):
178 178 pass
179 179 # Returning False will cause exceptions to propagate
180 180 return False
181 181
182 182 def current_length(self):
183 183 return self.shell.readline.get_current_history_length()
184 184
185 185 def get_readline_tail(self, n=10):
186 186 """Get the last n items in readline history."""
187 187 end = self.shell.readline.get_current_history_length() + 1
188 188 start = max(end-n, 1)
189 189 ghi = self.shell.readline.get_history_item
190 190 return [ghi(x) for x in range(start, end)]
191 191
192 192 #-----------------------------------------------------------------------------
193 193 # Main IPython class
194 194 #-----------------------------------------------------------------------------
195 195
196 196 class InteractiveShell(SingletonConfigurable):
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=0, 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 """
210 210 )
211 211 # TODO: remove all autoindent logic and put into frontends.
212 212 # We can't do this yet because even runlines uses the autoindent.
213 213 autoindent = CBool(True, config=True, help=
214 214 """
215 215 Autoindent IPython code entered interactively.
216 216 """
217 217 )
218 218 automagic = CBool(True, config=True, help=
219 219 """
220 220 Enable magic commands to be called without the leading %.
221 221 """
222 222 )
223 223 cache_size = Integer(1000, config=True, help=
224 224 """
225 225 Set the size of the output cache. The default is 1000, you can
226 226 change it permanently in your config file. Setting it to 0 completely
227 227 disables the caching system, and the minimum value accepted is 20 (if
228 228 you provide a value less than 20, it is reset to 0 and a warning is
229 229 issued). This limit is defined because otherwise you'll spend more
230 230 time re-flushing a too small cache than working
231 231 """
232 232 )
233 233 color_info = CBool(True, config=True, help=
234 234 """
235 235 Use colors for displaying information about objects. Because this
236 236 information is passed through a pager (like 'less'), and some pagers
237 237 get confused with color codes, this capability can be turned off.
238 238 """
239 239 )
240 240 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
241 241 default_value=get_default_colors(), config=True,
242 242 help="Set the color scheme (NoColor, Linux, or LightBG)."
243 243 )
244 244 colors_force = CBool(False, help=
245 245 """
246 246 Force use of ANSI color codes, regardless of OS and readline
247 247 availability.
248 248 """
249 249 # FIXME: This is essentially a hack to allow ZMQShell to show colors
250 250 # without readline on Win32. When the ZMQ formatting system is
251 251 # refactored, this should be removed.
252 252 )
253 253 debug = CBool(False, config=True)
254 254 deep_reload = CBool(False, config=True, help=
255 255 """
256 256 Enable deep (recursive) reloading by default. IPython can use the
257 257 deep_reload module which reloads changes in modules recursively (it
258 258 replaces the reload() function, so you don't need to change anything to
259 259 use it). deep_reload() forces a full reload of modules whose code may
260 260 have changed, which the default reload() function does not. When
261 261 deep_reload is off, IPython will use the normal reload(), but
262 262 deep_reload will still be available as dreload().
263 263 """
264 264 )
265 265 disable_failing_post_execute = CBool(False, config=True,
266 266 help="Don't call post-execute functions that have failed in the past."""
267 267 )
268 268 display_formatter = Instance(DisplayFormatter)
269 269 displayhook_class = Type(DisplayHook)
270 270 display_pub_class = Type(DisplayPublisher)
271 271
272 272 exit_now = CBool(False)
273 273 exiter = Instance(ExitAutocall)
274 274 def _exiter_default(self):
275 275 return ExitAutocall(self)
276 276 # Monotonically increasing execution counter
277 277 execution_count = Integer(1)
278 278 filename = Unicode("<ipython console>")
279 279 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
280 280
281 281 # Input splitter, to split entire cells of input into either individual
282 282 # interactive statements or whole blocks.
283 283 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
284 284 (), {})
285 285 logstart = CBool(False, config=True, help=
286 286 """
287 287 Start logging to the default log file.
288 288 """
289 289 )
290 290 logfile = Unicode('', config=True, help=
291 291 """
292 292 The name of the logfile to use.
293 293 """
294 294 )
295 295 logappend = Unicode('', config=True, help=
296 296 """
297 297 Start logging to the given file in append mode.
298 298 """
299 299 )
300 300 object_info_string_level = Enum((0,1,2), default_value=0,
301 301 config=True)
302 302 pdb = CBool(False, config=True, help=
303 303 """
304 304 Automatically call the pdb debugger after every exception.
305 305 """
306 306 )
307 307 multiline_history = CBool(sys.platform != 'win32', config=True,
308 308 help="Save multi-line entries as one entry in readline history"
309 309 )
310 310
311 311 # deprecated prompt traits:
312 312
313 313 prompt_in1 = Unicode('In [\\#]: ', config=True,
314 314 help="Deprecated, use PromptManager.in_template")
315 315 prompt_in2 = Unicode(' .\\D.: ', config=True,
316 316 help="Deprecated, use PromptManager.in2_template")
317 317 prompt_out = Unicode('Out[\\#]: ', config=True,
318 318 help="Deprecated, use PromptManager.out_template")
319 319 prompts_pad_left = CBool(True, config=True,
320 320 help="Deprecated, use PromptManager.justify")
321 321
322 322 def _prompt_trait_changed(self, name, old, new):
323 323 table = {
324 324 'prompt_in1' : 'in_template',
325 325 'prompt_in2' : 'in2_template',
326 326 'prompt_out' : 'out_template',
327 327 'prompts_pad_left' : 'justify',
328 328 }
329 329 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}\n".format(
330 330 name=name, newname=table[name])
331 331 )
332 332 # protect against weird cases where self.config may not exist:
333 333 if self.config is not None:
334 334 # propagate to corresponding PromptManager trait
335 335 setattr(self.config.PromptManager, table[name], new)
336 336
337 337 _prompt_in1_changed = _prompt_trait_changed
338 338 _prompt_in2_changed = _prompt_trait_changed
339 339 _prompt_out_changed = _prompt_trait_changed
340 340 _prompt_pad_left_changed = _prompt_trait_changed
341 341
342 342 show_rewritten_input = CBool(True, config=True,
343 343 help="Show rewritten input, e.g. for autocall."
344 344 )
345 345
346 346 quiet = CBool(False, config=True)
347 347
348 348 history_length = Integer(10000, config=True)
349 349
350 350 # The readline stuff will eventually be moved to the terminal subclass
351 351 # but for now, we can't do that as readline is welded in everywhere.
352 352 readline_use = CBool(True, config=True)
353 353 readline_remove_delims = Unicode('-/~', config=True)
354 354 # don't use \M- bindings by default, because they
355 355 # conflict with 8-bit encodings. See gh-58,gh-88
356 356 readline_parse_and_bind = List([
357 357 'tab: complete',
358 358 '"\C-l": clear-screen',
359 359 'set show-all-if-ambiguous on',
360 360 '"\C-o": tab-insert',
361 361 '"\C-r": reverse-search-history',
362 362 '"\C-s": forward-search-history',
363 363 '"\C-p": history-search-backward',
364 364 '"\C-n": history-search-forward',
365 365 '"\e[A": history-search-backward',
366 366 '"\e[B": history-search-forward',
367 367 '"\C-k": kill-line',
368 368 '"\C-u": unix-line-discard',
369 369 ], allow_none=False, config=True)
370 370
371 371 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
372 372 default_value='last_expr', config=True,
373 373 help="""
374 374 'all', 'last', 'last_expr' or 'none'," specifying which nodes should be
375 375 run interactively (displaying output from expressions).""")
376 376
377 377 # TODO: this part of prompt management should be moved to the frontends.
378 378 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
379 379 separate_in = SeparateUnicode('\n', config=True)
380 380 separate_out = SeparateUnicode('', config=True)
381 381 separate_out2 = SeparateUnicode('', config=True)
382 382 wildcards_case_sensitive = CBool(True, config=True)
383 383 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
384 384 default_value='Context', config=True)
385 385
386 386 # Subcomponents of InteractiveShell
387 387 alias_manager = Instance('IPython.core.alias.AliasManager')
388 388 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
389 389 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
390 390 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
391 391 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
392 392 plugin_manager = Instance('IPython.core.plugin.PluginManager')
393 393 payload_manager = Instance('IPython.core.payload.PayloadManager')
394 394 history_manager = Instance('IPython.core.history.HistoryManager')
395 395 magics_manager = Instance('IPython.core.magic.MagicsManager')
396 396
397 397 profile_dir = Instance('IPython.core.application.ProfileDir')
398 398 @property
399 399 def profile(self):
400 400 if self.profile_dir is not None:
401 401 name = os.path.basename(self.profile_dir.location)
402 402 return name.replace('profile_','')
403 403
404 404
405 405 # Private interface
406 406 _post_execute = Instance(dict)
407 407
408 408 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
409 409 user_module=None, user_ns=None,
410 410 custom_exceptions=((), None)):
411 411
412 412 # This is where traits with a config_key argument are updated
413 413 # from the values on config.
414 414 super(InteractiveShell, self).__init__(config=config)
415 415 self.configurables = [self]
416 416
417 417 # These are relatively independent and stateless
418 418 self.init_ipython_dir(ipython_dir)
419 419 self.init_profile_dir(profile_dir)
420 420 self.init_instance_attrs()
421 421 self.init_environment()
422 422
423 423 # Check if we're in a virtualenv, and set up sys.path.
424 424 self.init_virtualenv()
425 425
426 426 # Create namespaces (user_ns, user_global_ns, etc.)
427 427 self.init_create_namespaces(user_module, user_ns)
428 428 # This has to be done after init_create_namespaces because it uses
429 429 # something in self.user_ns, but before init_sys_modules, which
430 430 # is the first thing to modify sys.
431 431 # TODO: When we override sys.stdout and sys.stderr before this class
432 432 # is created, we are saving the overridden ones here. Not sure if this
433 433 # is what we want to do.
434 434 self.save_sys_module_state()
435 435 self.init_sys_modules()
436 436
437 437 # While we're trying to have each part of the code directly access what
438 438 # it needs without keeping redundant references to objects, we have too
439 439 # much legacy code that expects ip.db to exist.
440 440 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
441 441
442 442 self.init_history()
443 443 self.init_encoding()
444 444 self.init_prefilter()
445 445
446 446 self.init_syntax_highlighting()
447 447 self.init_hooks()
448 448 self.init_pushd_popd_magic()
449 449 # self.init_traceback_handlers use to be here, but we moved it below
450 450 # because it and init_io have to come after init_readline.
451 451 self.init_user_ns()
452 452 self.init_logger()
453 453 self.init_alias()
454 454 self.init_builtins()
455 455
456 456 # pre_config_initialization
457 457
458 458 # The next section should contain everything that was in ipmaker.
459 459 self.init_logstart()
460 460
461 461 # The following was in post_config_initialization
462 462 self.init_inspector()
463 463 # init_readline() must come before init_io(), because init_io uses
464 464 # readline related things.
465 465 self.init_readline()
466 466 # We save this here in case user code replaces raw_input, but it needs
467 467 # to be after init_readline(), because PyPy's readline works by replacing
468 468 # raw_input.
469 469 if py3compat.PY3:
470 470 self.raw_input_original = input
471 471 else:
472 472 self.raw_input_original = raw_input
473 473 # init_completer must come after init_readline, because it needs to
474 474 # know whether readline is present or not system-wide to configure the
475 475 # completers, since the completion machinery can now operate
476 476 # independently of readline (e.g. over the network)
477 477 self.init_completer()
478 478 # TODO: init_io() needs to happen before init_traceback handlers
479 479 # because the traceback handlers hardcode the stdout/stderr streams.
480 480 # This logic in in debugger.Pdb and should eventually be changed.
481 481 self.init_io()
482 482 self.init_traceback_handlers(custom_exceptions)
483 483 self.init_prompts()
484 484 self.init_display_formatter()
485 485 self.init_display_pub()
486 486 self.init_displayhook()
487 487 self.init_reload_doctest()
488 488 self.init_magics()
489 489 self.init_pdb()
490 490 self.init_extension_manager()
491 491 self.init_plugin_manager()
492 492 self.init_payload()
493 493 self.hooks.late_startup_hook()
494 494 atexit.register(self.atexit_operations)
495 495
496 496 def get_ipython(self):
497 497 """Return the currently running IPython instance."""
498 498 return self
499 499
500 500 #-------------------------------------------------------------------------
501 501 # Trait changed handlers
502 502 #-------------------------------------------------------------------------
503 503
504 504 def _ipython_dir_changed(self, name, new):
505 505 if not os.path.isdir(new):
506 506 os.makedirs(new, mode = 0777)
507 507
508 508 def set_autoindent(self,value=None):
509 509 """Set the autoindent flag, checking for readline support.
510 510
511 511 If called with no arguments, it acts as a toggle."""
512 512
513 513 if value != 0 and not self.has_readline:
514 514 if os.name == 'posix':
515 515 warn("The auto-indent feature requires the readline library")
516 516 self.autoindent = 0
517 517 return
518 518 if value is None:
519 519 self.autoindent = not self.autoindent
520 520 else:
521 521 self.autoindent = value
522 522
523 523 #-------------------------------------------------------------------------
524 524 # init_* methods called by __init__
525 525 #-------------------------------------------------------------------------
526 526
527 527 def init_ipython_dir(self, ipython_dir):
528 528 if ipython_dir is not None:
529 529 self.ipython_dir = ipython_dir
530 530 return
531 531
532 532 self.ipython_dir = get_ipython_dir()
533 533
534 534 def init_profile_dir(self, profile_dir):
535 535 if profile_dir is not None:
536 536 self.profile_dir = profile_dir
537 537 return
538 538 self.profile_dir =\
539 539 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
540 540
541 541 def init_instance_attrs(self):
542 542 self.more = False
543 543
544 544 # command compiler
545 545 self.compile = CachingCompiler()
546 546
547 547 # Make an empty namespace, which extension writers can rely on both
548 548 # existing and NEVER being used by ipython itself. This gives them a
549 549 # convenient location for storing additional information and state
550 550 # their extensions may require, without fear of collisions with other
551 551 # ipython names that may develop later.
552 552 self.meta = Struct()
553 553
554 554 # Temporary files used for various purposes. Deleted at exit.
555 555 self.tempfiles = []
556 556
557 557 # Keep track of readline usage (later set by init_readline)
558 558 self.has_readline = False
559 559
560 560 # keep track of where we started running (mainly for crash post-mortem)
561 561 # This is not being used anywhere currently.
562 562 self.starting_dir = os.getcwdu()
563 563
564 564 # Indentation management
565 565 self.indent_current_nsp = 0
566 566
567 567 # Dict to track post-execution functions that have been registered
568 568 self._post_execute = {}
569 569
570 570 def init_environment(self):
571 571 """Any changes we need to make to the user's environment."""
572 572 pass
573 573
574 574 def init_encoding(self):
575 575 # Get system encoding at startup time. Certain terminals (like Emacs
576 576 # under Win32 have it set to None, and we need to have a known valid
577 577 # encoding to use in the raw_input() method
578 578 try:
579 579 self.stdin_encoding = sys.stdin.encoding or 'ascii'
580 580 except AttributeError:
581 581 self.stdin_encoding = 'ascii'
582 582
583 583 def init_syntax_highlighting(self):
584 584 # Python source parser/formatter for syntax highlighting
585 585 pyformat = PyColorize.Parser().format
586 586 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
587 587
588 588 def init_pushd_popd_magic(self):
589 589 # for pushd/popd management
590 590 self.home_dir = get_home_dir()
591 591
592 592 self.dir_stack = []
593 593
594 594 def init_logger(self):
595 595 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
596 596 logmode='rotate')
597 597
598 598 def init_logstart(self):
599 599 """Initialize logging in case it was requested at the command line.
600 600 """
601 601 if self.logappend:
602 602 self.magic('logstart %s append' % self.logappend)
603 603 elif self.logfile:
604 604 self.magic('logstart %' % self.logfile)
605 605 elif self.logstart:
606 606 self.magic('logstart')
607 607
608 608 def init_builtins(self):
609 609 # A single, static flag that we set to True. Its presence indicates
610 610 # that an IPython shell has been created, and we make no attempts at
611 611 # removing on exit or representing the existence of more than one
612 612 # IPython at a time.
613 613 builtin_mod.__dict__['__IPYTHON__'] = True
614 614
615 615 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
616 616 # manage on enter/exit, but with all our shells it's virtually
617 617 # impossible to get all the cases right. We're leaving the name in for
618 618 # those who adapted their codes to check for this flag, but will
619 619 # eventually remove it after a few more releases.
620 620 builtin_mod.__dict__['__IPYTHON__active'] = \
621 621 'Deprecated, check for __IPYTHON__'
622 622
623 623 self.builtin_trap = BuiltinTrap(shell=self)
624 624
625 625 def init_inspector(self):
626 626 # Object inspector
627 627 self.inspector = oinspect.Inspector(oinspect.InspectColors,
628 628 PyColorize.ANSICodeColors,
629 629 'NoColor',
630 630 self.object_info_string_level)
631 631
632 632 def init_io(self):
633 633 # This will just use sys.stdout and sys.stderr. If you want to
634 634 # override sys.stdout and sys.stderr themselves, you need to do that
635 635 # *before* instantiating this class, because io holds onto
636 636 # references to the underlying streams.
637 637 if sys.platform == 'win32' and self.has_readline:
638 638 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
639 639 else:
640 640 io.stdout = io.IOStream(sys.stdout)
641 641 io.stderr = io.IOStream(sys.stderr)
642 642
643 643 def init_prompts(self):
644 644 self.prompt_manager = PromptManager(shell=self, config=self.config)
645 645 self.configurables.append(self.prompt_manager)
646 646 # Set system prompts, so that scripts can decide if they are running
647 647 # interactively.
648 648 sys.ps1 = 'In : '
649 649 sys.ps2 = '...: '
650 650 sys.ps3 = 'Out: '
651 651
652 652 def init_display_formatter(self):
653 653 self.display_formatter = DisplayFormatter(config=self.config)
654 654 self.configurables.append(self.display_formatter)
655 655
656 656 def init_display_pub(self):
657 657 self.display_pub = self.display_pub_class(config=self.config)
658 658 self.configurables.append(self.display_pub)
659 659
660 660 def init_displayhook(self):
661 661 # Initialize displayhook, set in/out prompts and printing system
662 662 self.displayhook = self.displayhook_class(
663 663 config=self.config,
664 664 shell=self,
665 665 cache_size=self.cache_size,
666 666 )
667 667 self.configurables.append(self.displayhook)
668 668 # This is a context manager that installs/revmoes the displayhook at
669 669 # the appropriate time.
670 670 self.display_trap = DisplayTrap(hook=self.displayhook)
671 671
672 672 def init_reload_doctest(self):
673 673 # Do a proper resetting of doctest, including the necessary displayhook
674 674 # monkeypatching
675 675 try:
676 676 doctest_reload()
677 677 except ImportError:
678 678 warn("doctest module does not exist.")
679 679
680 680 def init_virtualenv(self):
681 681 """Add a virtualenv to sys.path so the user can import modules from it.
682 682 This isn't perfect: it doesn't use the Python interpreter with which the
683 683 virtualenv was built, and it ignores the --no-site-packages option. A
684 684 warning will appear suggesting the user installs IPython in the
685 685 virtualenv, but for many cases, it probably works well enough.
686 686
687 687 Adapted from code snippets online.
688 688
689 689 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
690 690 """
691 691 if 'VIRTUAL_ENV' not in os.environ:
692 692 # Not in a virtualenv
693 693 return
694 694
695 695 if sys.executable.startswith(os.environ['VIRTUAL_ENV']):
696 696 # Running properly in the virtualenv, don't need to do anything
697 697 return
698 698
699 699 warn("Attempting to work in a virtualenv. If you encounter problems, please "
700 700 "install IPython inside the virtualenv.\n")
701 701 if sys.platform == "win32":
702 702 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
703 703 else:
704 704 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
705 705 'python%d.%d' % sys.version_info[:2], 'site-packages')
706 706
707 707 import site
708 708 sys.path.insert(0, virtual_env)
709 709 site.addsitedir(virtual_env)
710 710
711 711 #-------------------------------------------------------------------------
712 712 # Things related to injections into the sys module
713 713 #-------------------------------------------------------------------------
714 714
715 715 def save_sys_module_state(self):
716 716 """Save the state of hooks in the sys module.
717 717
718 718 This has to be called after self.user_module is created.
719 719 """
720 720 self._orig_sys_module_state = {}
721 721 self._orig_sys_module_state['stdin'] = sys.stdin
722 722 self._orig_sys_module_state['stdout'] = sys.stdout
723 723 self._orig_sys_module_state['stderr'] = sys.stderr
724 724 self._orig_sys_module_state['excepthook'] = sys.excepthook
725 725 self._orig_sys_modules_main_name = self.user_module.__name__
726 726 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
727 727
728 728 def restore_sys_module_state(self):
729 729 """Restore the state of the sys module."""
730 730 try:
731 731 for k, v in self._orig_sys_module_state.iteritems():
732 732 setattr(sys, k, v)
733 733 except AttributeError:
734 734 pass
735 735 # Reset what what done in self.init_sys_modules
736 736 if self._orig_sys_modules_main_mod is not None:
737 737 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
738 738
739 739 #-------------------------------------------------------------------------
740 740 # Things related to hooks
741 741 #-------------------------------------------------------------------------
742 742
743 743 def init_hooks(self):
744 744 # hooks holds pointers used for user-side customizations
745 745 self.hooks = Struct()
746 746
747 747 self.strdispatchers = {}
748 748
749 749 # Set all default hooks, defined in the IPython.hooks module.
750 750 hooks = IPython.core.hooks
751 751 for hook_name in hooks.__all__:
752 752 # default hooks have priority 100, i.e. low; user hooks should have
753 753 # 0-100 priority
754 754 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
755 755
756 756 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
757 757 """set_hook(name,hook) -> sets an internal IPython hook.
758 758
759 759 IPython exposes some of its internal API as user-modifiable hooks. By
760 760 adding your function to one of these hooks, you can modify IPython's
761 761 behavior to call at runtime your own routines."""
762 762
763 763 # At some point in the future, this should validate the hook before it
764 764 # accepts it. Probably at least check that the hook takes the number
765 765 # of args it's supposed to.
766 766
767 767 f = types.MethodType(hook,self)
768 768
769 769 # check if the hook is for strdispatcher first
770 770 if str_key is not None:
771 771 sdp = self.strdispatchers.get(name, StrDispatch())
772 772 sdp.add_s(str_key, f, priority )
773 773 self.strdispatchers[name] = sdp
774 774 return
775 775 if re_key is not None:
776 776 sdp = self.strdispatchers.get(name, StrDispatch())
777 777 sdp.add_re(re.compile(re_key), f, priority )
778 778 self.strdispatchers[name] = sdp
779 779 return
780 780
781 781 dp = getattr(self.hooks, name, None)
782 782 if name not in IPython.core.hooks.__all__:
783 783 print "Warning! Hook '%s' is not one of %s" % \
784 784 (name, IPython.core.hooks.__all__ )
785 785 if not dp:
786 786 dp = IPython.core.hooks.CommandChainDispatcher()
787 787
788 788 try:
789 789 dp.add(f,priority)
790 790 except AttributeError:
791 791 # it was not commandchain, plain old func - replace
792 792 dp = f
793 793
794 794 setattr(self.hooks,name, dp)
795 795
796 796 def register_post_execute(self, func):
797 797 """Register a function for calling after code execution.
798 798 """
799 799 if not callable(func):
800 800 raise ValueError('argument %s must be callable' % func)
801 801 self._post_execute[func] = True
802 802
803 803 #-------------------------------------------------------------------------
804 804 # Things related to the "main" module
805 805 #-------------------------------------------------------------------------
806 806
807 807 def new_main_mod(self,ns=None):
808 808 """Return a new 'main' module object for user code execution.
809 809 """
810 810 main_mod = self._user_main_module
811 811 init_fakemod_dict(main_mod,ns)
812 812 return main_mod
813 813
814 814 def cache_main_mod(self,ns,fname):
815 815 """Cache a main module's namespace.
816 816
817 817 When scripts are executed via %run, we must keep a reference to the
818 818 namespace of their __main__ module (a FakeModule instance) around so
819 819 that Python doesn't clear it, rendering objects defined therein
820 820 useless.
821 821
822 822 This method keeps said reference in a private dict, keyed by the
823 823 absolute path of the module object (which corresponds to the script
824 824 path). This way, for multiple executions of the same script we only
825 825 keep one copy of the namespace (the last one), thus preventing memory
826 826 leaks from old references while allowing the objects from the last
827 827 execution to be accessible.
828 828
829 829 Note: we can not allow the actual FakeModule instances to be deleted,
830 830 because of how Python tears down modules (it hard-sets all their
831 831 references to None without regard for reference counts). This method
832 832 must therefore make a *copy* of the given namespace, to allow the
833 833 original module's __dict__ to be cleared and reused.
834 834
835 835
836 836 Parameters
837 837 ----------
838 838 ns : a namespace (a dict, typically)
839 839
840 840 fname : str
841 841 Filename associated with the namespace.
842 842
843 843 Examples
844 844 --------
845 845
846 846 In [10]: import IPython
847 847
848 848 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
849 849
850 850 In [12]: IPython.__file__ in _ip._main_ns_cache
851 851 Out[12]: True
852 852 """
853 853 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
854 854
855 855 def clear_main_mod_cache(self):
856 856 """Clear the cache of main modules.
857 857
858 858 Mainly for use by utilities like %reset.
859 859
860 860 Examples
861 861 --------
862 862
863 863 In [15]: import IPython
864 864
865 865 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
866 866
867 867 In [17]: len(_ip._main_ns_cache) > 0
868 868 Out[17]: True
869 869
870 870 In [18]: _ip.clear_main_mod_cache()
871 871
872 872 In [19]: len(_ip._main_ns_cache) == 0
873 873 Out[19]: True
874 874 """
875 875 self._main_ns_cache.clear()
876 876
877 877 #-------------------------------------------------------------------------
878 878 # Things related to debugging
879 879 #-------------------------------------------------------------------------
880 880
881 881 def init_pdb(self):
882 882 # Set calling of pdb on exceptions
883 883 # self.call_pdb is a property
884 884 self.call_pdb = self.pdb
885 885
886 886 def _get_call_pdb(self):
887 887 return self._call_pdb
888 888
889 889 def _set_call_pdb(self,val):
890 890
891 891 if val not in (0,1,False,True):
892 892 raise ValueError,'new call_pdb value must be boolean'
893 893
894 894 # store value in instance
895 895 self._call_pdb = val
896 896
897 897 # notify the actual exception handlers
898 898 self.InteractiveTB.call_pdb = val
899 899
900 900 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
901 901 'Control auto-activation of pdb at exceptions')
902 902
903 903 def debugger(self,force=False):
904 904 """Call the pydb/pdb debugger.
905 905
906 906 Keywords:
907 907
908 908 - force(False): by default, this routine checks the instance call_pdb
909 909 flag and does not actually invoke the debugger if the flag is false.
910 910 The 'force' option forces the debugger to activate even if the flag
911 911 is false.
912 912 """
913 913
914 914 if not (force or self.call_pdb):
915 915 return
916 916
917 917 if not hasattr(sys,'last_traceback'):
918 918 error('No traceback has been produced, nothing to debug.')
919 919 return
920 920
921 921 # use pydb if available
922 922 if debugger.has_pydb:
923 923 from pydb import pm
924 924 else:
925 925 # fallback to our internal debugger
926 926 pm = lambda : self.InteractiveTB.debugger(force=True)
927 927
928 928 with self.readline_no_record:
929 929 pm()
930 930
931 931 #-------------------------------------------------------------------------
932 932 # Things related to IPython's various namespaces
933 933 #-------------------------------------------------------------------------
934 934 default_user_namespaces = True
935 935
936 936 def init_create_namespaces(self, user_module=None, user_ns=None):
937 937 # Create the namespace where the user will operate. user_ns is
938 938 # normally the only one used, and it is passed to the exec calls as
939 939 # the locals argument. But we do carry a user_global_ns namespace
940 940 # given as the exec 'globals' argument, This is useful in embedding
941 941 # situations where the ipython shell opens in a context where the
942 942 # distinction between locals and globals is meaningful. For
943 943 # non-embedded contexts, it is just the same object as the user_ns dict.
944 944
945 945 # FIXME. For some strange reason, __builtins__ is showing up at user
946 946 # level as a dict instead of a module. This is a manual fix, but I
947 947 # should really track down where the problem is coming from. Alex
948 948 # Schmolck reported this problem first.
949 949
950 950 # A useful post by Alex Martelli on this topic:
951 951 # Re: inconsistent value from __builtins__
952 952 # Von: Alex Martelli <aleaxit@yahoo.com>
953 953 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
954 954 # Gruppen: comp.lang.python
955 955
956 956 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
957 957 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
958 958 # > <type 'dict'>
959 959 # > >>> print type(__builtins__)
960 960 # > <type 'module'>
961 961 # > Is this difference in return value intentional?
962 962
963 963 # Well, it's documented that '__builtins__' can be either a dictionary
964 964 # or a module, and it's been that way for a long time. Whether it's
965 965 # intentional (or sensible), I don't know. In any case, the idea is
966 966 # that if you need to access the built-in namespace directly, you
967 967 # should start with "import __builtin__" (note, no 's') which will
968 968 # definitely give you a module. Yeah, it's somewhat confusing:-(.
969 969
970 970 # These routines return a properly built module and dict as needed by
971 971 # the rest of the code, and can also be used by extension writers to
972 972 # generate properly initialized namespaces.
973 973 if (user_ns is not None) or (user_module is not None):
974 974 self.default_user_namespaces = False
975 975 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
976 976
977 977 # A record of hidden variables we have added to the user namespace, so
978 978 # we can list later only variables defined in actual interactive use.
979 979 self.user_ns_hidden = set()
980 980
981 981 # Now that FakeModule produces a real module, we've run into a nasty
982 982 # problem: after script execution (via %run), the module where the user
983 983 # code ran is deleted. Now that this object is a true module (needed
984 984 # so docetst and other tools work correctly), the Python module
985 985 # teardown mechanism runs over it, and sets to None every variable
986 986 # present in that module. Top-level references to objects from the
987 987 # script survive, because the user_ns is updated with them. However,
988 988 # calling functions defined in the script that use other things from
989 989 # the script will fail, because the function's closure had references
990 990 # to the original objects, which are now all None. So we must protect
991 991 # these modules from deletion by keeping a cache.
992 992 #
993 993 # To avoid keeping stale modules around (we only need the one from the
994 994 # last run), we use a dict keyed with the full path to the script, so
995 995 # only the last version of the module is held in the cache. Note,
996 996 # however, that we must cache the module *namespace contents* (their
997 997 # __dict__). Because if we try to cache the actual modules, old ones
998 998 # (uncached) could be destroyed while still holding references (such as
999 999 # those held by GUI objects that tend to be long-lived)>
1000 1000 #
1001 1001 # The %reset command will flush this cache. See the cache_main_mod()
1002 1002 # and clear_main_mod_cache() methods for details on use.
1003 1003
1004 1004 # This is the cache used for 'main' namespaces
1005 1005 self._main_ns_cache = {}
1006 1006 # And this is the single instance of FakeModule whose __dict__ we keep
1007 1007 # copying and clearing for reuse on each %run
1008 1008 self._user_main_module = FakeModule()
1009 1009
1010 1010 # A table holding all the namespaces IPython deals with, so that
1011 1011 # introspection facilities can search easily.
1012 1012 self.ns_table = {'user_global':self.user_module.__dict__,
1013 1013 'user_local':self.user_ns,
1014 1014 'builtin':builtin_mod.__dict__
1015 1015 }
1016 1016
1017 1017 @property
1018 1018 def user_global_ns(self):
1019 1019 return self.user_module.__dict__
1020 1020
1021 1021 def prepare_user_module(self, user_module=None, user_ns=None):
1022 1022 """Prepare the module and namespace in which user code will be run.
1023 1023
1024 1024 When IPython is started normally, both parameters are None: a new module
1025 1025 is created automatically, and its __dict__ used as the namespace.
1026 1026
1027 1027 If only user_module is provided, its __dict__ is used as the namespace.
1028 1028 If only user_ns is provided, a dummy module is created, and user_ns
1029 1029 becomes the global namespace. If both are provided (as they may be
1030 1030 when embedding), user_ns is the local namespace, and user_module
1031 1031 provides the global namespace.
1032 1032
1033 1033 Parameters
1034 1034 ----------
1035 1035 user_module : module, optional
1036 1036 The current user module in which IPython is being run. If None,
1037 1037 a clean module will be created.
1038 1038 user_ns : dict, optional
1039 1039 A namespace in which to run interactive commands.
1040 1040
1041 1041 Returns
1042 1042 -------
1043 1043 A tuple of user_module and user_ns, each properly initialised.
1044 1044 """
1045 1045 if user_module is None and user_ns is not None:
1046 1046 user_ns.setdefault("__name__", "__main__")
1047 1047 class DummyMod(object):
1048 1048 "A dummy module used for IPython's interactive namespace."
1049 1049 pass
1050 1050 user_module = DummyMod()
1051 1051 user_module.__dict__ = user_ns
1052 1052
1053 1053 if user_module is None:
1054 1054 user_module = types.ModuleType("__main__",
1055 1055 doc="Automatically created module for IPython interactive environment")
1056 1056
1057 1057 # We must ensure that __builtin__ (without the final 's') is always
1058 1058 # available and pointing to the __builtin__ *module*. For more details:
1059 1059 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1060 1060 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1061 1061 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1062 1062
1063 1063 if user_ns is None:
1064 1064 user_ns = user_module.__dict__
1065 1065
1066 1066 return user_module, user_ns
1067 1067
1068 1068 def init_sys_modules(self):
1069 1069 # We need to insert into sys.modules something that looks like a
1070 1070 # module but which accesses the IPython namespace, for shelve and
1071 1071 # pickle to work interactively. Normally they rely on getting
1072 1072 # everything out of __main__, but for embedding purposes each IPython
1073 1073 # instance has its own private namespace, so we can't go shoving
1074 1074 # everything into __main__.
1075 1075
1076 1076 # note, however, that we should only do this for non-embedded
1077 1077 # ipythons, which really mimic the __main__.__dict__ with their own
1078 1078 # namespace. Embedded instances, on the other hand, should not do
1079 1079 # this because they need to manage the user local/global namespaces
1080 1080 # only, but they live within a 'normal' __main__ (meaning, they
1081 1081 # shouldn't overtake the execution environment of the script they're
1082 1082 # embedded in).
1083 1083
1084 1084 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1085 1085 main_name = self.user_module.__name__
1086 1086 sys.modules[main_name] = self.user_module
1087 1087
1088 1088 def init_user_ns(self):
1089 1089 """Initialize all user-visible namespaces to their minimum defaults.
1090 1090
1091 1091 Certain history lists are also initialized here, as they effectively
1092 1092 act as user namespaces.
1093 1093
1094 1094 Notes
1095 1095 -----
1096 1096 All data structures here are only filled in, they are NOT reset by this
1097 1097 method. If they were not empty before, data will simply be added to
1098 1098 therm.
1099 1099 """
1100 1100 # This function works in two parts: first we put a few things in
1101 1101 # user_ns, and we sync that contents into user_ns_hidden so that these
1102 1102 # initial variables aren't shown by %who. After the sync, we add the
1103 1103 # rest of what we *do* want the user to see with %who even on a new
1104 1104 # session (probably nothing, so theye really only see their own stuff)
1105 1105
1106 1106 # The user dict must *always* have a __builtin__ reference to the
1107 1107 # Python standard __builtin__ namespace, which must be imported.
1108 1108 # This is so that certain operations in prompt evaluation can be
1109 1109 # reliably executed with builtins. Note that we can NOT use
1110 1110 # __builtins__ (note the 's'), because that can either be a dict or a
1111 1111 # module, and can even mutate at runtime, depending on the context
1112 1112 # (Python makes no guarantees on it). In contrast, __builtin__ is
1113 1113 # always a module object, though it must be explicitly imported.
1114 1114
1115 1115 # For more details:
1116 1116 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1117 1117 ns = dict()
1118 1118
1119 1119 # Put 'help' in the user namespace
1120 1120 try:
1121 1121 from site import _Helper
1122 1122 ns['help'] = _Helper()
1123 1123 except ImportError:
1124 1124 warn('help() not available - check site.py')
1125 1125
1126 1126 # make global variables for user access to the histories
1127 1127 ns['_ih'] = self.history_manager.input_hist_parsed
1128 1128 ns['_oh'] = self.history_manager.output_hist
1129 1129 ns['_dh'] = self.history_manager.dir_hist
1130 1130
1131 1131 ns['_sh'] = shadowns
1132 1132
1133 1133 # user aliases to input and output histories. These shouldn't show up
1134 1134 # in %who, as they can have very large reprs.
1135 1135 ns['In'] = self.history_manager.input_hist_parsed
1136 1136 ns['Out'] = self.history_manager.output_hist
1137 1137
1138 1138 # Store myself as the public api!!!
1139 1139 ns['get_ipython'] = self.get_ipython
1140 1140
1141 1141 ns['exit'] = self.exiter
1142 1142 ns['quit'] = self.exiter
1143 1143
1144 1144 # Sync what we've added so far to user_ns_hidden so these aren't seen
1145 1145 # by %who
1146 1146 self.user_ns_hidden.update(ns)
1147 1147
1148 1148 # Anything put into ns now would show up in %who. Think twice before
1149 1149 # putting anything here, as we really want %who to show the user their
1150 1150 # stuff, not our variables.
1151 1151
1152 1152 # Finally, update the real user's namespace
1153 1153 self.user_ns.update(ns)
1154 1154
1155 1155 @property
1156 1156 def all_ns_refs(self):
1157 1157 """Get a list of references to all the namespace dictionaries in which
1158 1158 IPython might store a user-created object.
1159 1159
1160 1160 Note that this does not include the displayhook, which also caches
1161 1161 objects from the output."""
1162 1162 return [self.user_ns, self.user_global_ns,
1163 1163 self._user_main_module.__dict__] + self._main_ns_cache.values()
1164 1164
1165 1165 def reset(self, new_session=True):
1166 1166 """Clear all internal namespaces, and attempt to release references to
1167 1167 user objects.
1168 1168
1169 1169 If new_session is True, a new history session will be opened.
1170 1170 """
1171 1171 # Clear histories
1172 1172 self.history_manager.reset(new_session)
1173 1173 # Reset counter used to index all histories
1174 1174 if new_session:
1175 1175 self.execution_count = 1
1176 1176
1177 1177 # Flush cached output items
1178 1178 if self.displayhook.do_full_cache:
1179 1179 self.displayhook.flush()
1180 1180
1181 1181 # The main execution namespaces must be cleared very carefully,
1182 1182 # skipping the deletion of the builtin-related keys, because doing so
1183 1183 # would cause errors in many object's __del__ methods.
1184 1184 if self.user_ns is not self.user_global_ns:
1185 1185 self.user_ns.clear()
1186 1186 ns = self.user_global_ns
1187 1187 drop_keys = set(ns.keys())
1188 1188 drop_keys.discard('__builtin__')
1189 1189 drop_keys.discard('__builtins__')
1190 1190 drop_keys.discard('__name__')
1191 1191 for k in drop_keys:
1192 1192 del ns[k]
1193 1193
1194 1194 self.user_ns_hidden.clear()
1195 1195
1196 1196 # Restore the user namespaces to minimal usability
1197 1197 self.init_user_ns()
1198 1198
1199 1199 # Restore the default and user aliases
1200 1200 self.alias_manager.clear_aliases()
1201 1201 self.alias_manager.init_aliases()
1202 1202
1203 1203 # Flush the private list of module references kept for script
1204 1204 # execution protection
1205 1205 self.clear_main_mod_cache()
1206 1206
1207 1207 # Clear out the namespace from the last %run
1208 1208 self.new_main_mod()
1209 1209
1210 1210 def del_var(self, varname, by_name=False):
1211 1211 """Delete a variable from the various namespaces, so that, as
1212 1212 far as possible, we're not keeping any hidden references to it.
1213 1213
1214 1214 Parameters
1215 1215 ----------
1216 1216 varname : str
1217 1217 The name of the variable to delete.
1218 1218 by_name : bool
1219 1219 If True, delete variables with the given name in each
1220 1220 namespace. If False (default), find the variable in the user
1221 1221 namespace, and delete references to it.
1222 1222 """
1223 1223 if varname in ('__builtin__', '__builtins__'):
1224 1224 raise ValueError("Refusing to delete %s" % varname)
1225 1225
1226 1226 ns_refs = self.all_ns_refs
1227 1227
1228 1228 if by_name: # Delete by name
1229 1229 for ns in ns_refs:
1230 1230 try:
1231 1231 del ns[varname]
1232 1232 except KeyError:
1233 1233 pass
1234 1234 else: # Delete by object
1235 1235 try:
1236 1236 obj = self.user_ns[varname]
1237 1237 except KeyError:
1238 1238 raise NameError("name '%s' is not defined" % varname)
1239 1239 # Also check in output history
1240 1240 ns_refs.append(self.history_manager.output_hist)
1241 1241 for ns in ns_refs:
1242 1242 to_delete = [n for n, o in ns.iteritems() if o is obj]
1243 1243 for name in to_delete:
1244 1244 del ns[name]
1245 1245
1246 1246 # displayhook keeps extra references, but not in a dictionary
1247 1247 for name in ('_', '__', '___'):
1248 1248 if getattr(self.displayhook, name) is obj:
1249 1249 setattr(self.displayhook, name, None)
1250 1250
1251 1251 def reset_selective(self, regex=None):
1252 1252 """Clear selective variables from internal namespaces based on a
1253 1253 specified regular expression.
1254 1254
1255 1255 Parameters
1256 1256 ----------
1257 1257 regex : string or compiled pattern, optional
1258 1258 A regular expression pattern that will be used in searching
1259 1259 variable names in the users namespaces.
1260 1260 """
1261 1261 if regex is not None:
1262 1262 try:
1263 1263 m = re.compile(regex)
1264 1264 except TypeError:
1265 1265 raise TypeError('regex must be a string or compiled pattern')
1266 1266 # Search for keys in each namespace that match the given regex
1267 1267 # If a match is found, delete the key/value pair.
1268 1268 for ns in self.all_ns_refs:
1269 1269 for var in ns:
1270 1270 if m.search(var):
1271 1271 del ns[var]
1272 1272
1273 1273 def push(self, variables, interactive=True):
1274 1274 """Inject a group of variables into the IPython user namespace.
1275 1275
1276 1276 Parameters
1277 1277 ----------
1278 1278 variables : dict, str or list/tuple of str
1279 1279 The variables to inject into the user's namespace. If a dict, a
1280 1280 simple update is done. If a str, the string is assumed to have
1281 1281 variable names separated by spaces. A list/tuple of str can also
1282 1282 be used to give the variable names. If just the variable names are
1283 1283 give (list/tuple/str) then the variable values looked up in the
1284 1284 callers frame.
1285 1285 interactive : bool
1286 1286 If True (default), the variables will be listed with the ``who``
1287 1287 magic.
1288 1288 """
1289 1289 vdict = None
1290 1290
1291 1291 # We need a dict of name/value pairs to do namespace updates.
1292 1292 if isinstance(variables, dict):
1293 1293 vdict = variables
1294 1294 elif isinstance(variables, (basestring, list, tuple)):
1295 1295 if isinstance(variables, basestring):
1296 1296 vlist = variables.split()
1297 1297 else:
1298 1298 vlist = variables
1299 1299 vdict = {}
1300 1300 cf = sys._getframe(1)
1301 1301 for name in vlist:
1302 1302 try:
1303 1303 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1304 1304 except:
1305 1305 print ('Could not get variable %s from %s' %
1306 1306 (name,cf.f_code.co_name))
1307 1307 else:
1308 1308 raise ValueError('variables must be a dict/str/list/tuple')
1309 1309
1310 1310 # Propagate variables to user namespace
1311 1311 self.user_ns.update(vdict)
1312 1312
1313 1313 # And configure interactive visibility
1314 1314 user_ns_hidden = self.user_ns_hidden
1315 1315 if interactive:
1316 1316 user_ns_hidden.difference_update(vdict)
1317 1317 else:
1318 1318 user_ns_hidden.update(vdict)
1319 1319
1320 1320 def drop_by_id(self, variables):
1321 1321 """Remove a dict of variables from the user namespace, if they are the
1322 1322 same as the values in the dictionary.
1323 1323
1324 1324 This is intended for use by extensions: variables that they've added can
1325 1325 be taken back out if they are unloaded, without removing any that the
1326 1326 user has overwritten.
1327 1327
1328 1328 Parameters
1329 1329 ----------
1330 1330 variables : dict
1331 1331 A dictionary mapping object names (as strings) to the objects.
1332 1332 """
1333 1333 for name, obj in variables.iteritems():
1334 1334 if name in self.user_ns and self.user_ns[name] is obj:
1335 1335 del self.user_ns[name]
1336 1336 self.user_ns_hidden.discard(name)
1337 1337
1338 1338 #-------------------------------------------------------------------------
1339 1339 # Things related to object introspection
1340 1340 #-------------------------------------------------------------------------
1341 1341
1342 1342 def _ofind(self, oname, namespaces=None):
1343 1343 """Find an object in the available namespaces.
1344 1344
1345 1345 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1346 1346
1347 1347 Has special code to detect magic functions.
1348 1348 """
1349 1349 oname = oname.strip()
1350 1350 #print '1- oname: <%r>' % oname # dbg
1351 1351 if not py3compat.isidentifier(oname.lstrip(ESC_MAGIC), dotted=True):
1352 1352 return dict(found=False)
1353 1353
1354 1354 alias_ns = None
1355 1355 if namespaces is None:
1356 1356 # Namespaces to search in:
1357 1357 # Put them in a list. The order is important so that we
1358 1358 # find things in the same order that Python finds them.
1359 1359 namespaces = [ ('Interactive', self.user_ns),
1360 1360 ('Interactive (global)', self.user_global_ns),
1361 1361 ('Python builtin', builtin_mod.__dict__),
1362 1362 ('Alias', self.alias_manager.alias_table),
1363 1363 ]
1364 1364 alias_ns = self.alias_manager.alias_table
1365 1365
1366 1366 # initialize results to 'null'
1367 1367 found = False; obj = None; ospace = None; ds = None;
1368 1368 ismagic = False; isalias = False; parent = None
1369 1369
1370 1370 # We need to special-case 'print', which as of python2.6 registers as a
1371 1371 # function but should only be treated as one if print_function was
1372 1372 # loaded with a future import. In this case, just bail.
1373 1373 if (oname == 'print' and not py3compat.PY3 and not \
1374 1374 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1375 1375 return {'found':found, 'obj':obj, 'namespace':ospace,
1376 1376 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1377 1377
1378 1378 # Look for the given name by splitting it in parts. If the head is
1379 1379 # found, then we look for all the remaining parts as members, and only
1380 1380 # declare success if we can find them all.
1381 1381 oname_parts = oname.split('.')
1382 1382 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1383 1383 for nsname,ns in namespaces:
1384 1384 try:
1385 1385 obj = ns[oname_head]
1386 1386 except KeyError:
1387 1387 continue
1388 1388 else:
1389 1389 #print 'oname_rest:', oname_rest # dbg
1390 1390 for part in oname_rest:
1391 1391 try:
1392 1392 parent = obj
1393 1393 obj = getattr(obj,part)
1394 1394 except:
1395 1395 # Blanket except b/c some badly implemented objects
1396 1396 # allow __getattr__ to raise exceptions other than
1397 1397 # AttributeError, which then crashes IPython.
1398 1398 break
1399 1399 else:
1400 1400 # If we finish the for loop (no break), we got all members
1401 1401 found = True
1402 1402 ospace = nsname
1403 1403 if ns == alias_ns:
1404 1404 isalias = True
1405 1405 break # namespace loop
1406 1406
1407 1407 # Try to see if it's magic
1408 1408 if not found:
1409 1409 if oname.startswith(ESC_MAGIC):
1410 1410 oname = oname.lstrip(ESC_MAGIC)
1411 1411 obj = self.find_line_magic(oname)
1412 1412 if obj is None:
1413 1413 obj = self.find_cell_magic(oname)
1414 1414 if obj is not None:
1415 1415 found = True
1416 1416 ospace = 'IPython internal'
1417 1417 ismagic = True
1418 1418
1419 1419 # Last try: special-case some literals like '', [], {}, etc:
1420 1420 if not found and oname_head in ["''",'""','[]','{}','()']:
1421 1421 obj = eval(oname_head)
1422 1422 found = True
1423 1423 ospace = 'Interactive'
1424 1424
1425 1425 return {'found':found, 'obj':obj, 'namespace':ospace,
1426 1426 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1427 1427
1428 1428 def _ofind_property(self, oname, info):
1429 1429 """Second part of object finding, to look for property details."""
1430 1430 if info.found:
1431 1431 # Get the docstring of the class property if it exists.
1432 1432 path = oname.split('.')
1433 1433 root = '.'.join(path[:-1])
1434 1434 if info.parent is not None:
1435 1435 try:
1436 1436 target = getattr(info.parent, '__class__')
1437 1437 # The object belongs to a class instance.
1438 1438 try:
1439 1439 target = getattr(target, path[-1])
1440 1440 # The class defines the object.
1441 1441 if isinstance(target, property):
1442 1442 oname = root + '.__class__.' + path[-1]
1443 1443 info = Struct(self._ofind(oname))
1444 1444 except AttributeError: pass
1445 1445 except AttributeError: pass
1446 1446
1447 1447 # We return either the new info or the unmodified input if the object
1448 1448 # hadn't been found
1449 1449 return info
1450 1450
1451 1451 def _object_find(self, oname, namespaces=None):
1452 1452 """Find an object and return a struct with info about it."""
1453 1453 inf = Struct(self._ofind(oname, namespaces))
1454 1454 return Struct(self._ofind_property(oname, inf))
1455 1455
1456 1456 def _inspect(self, meth, oname, namespaces=None, **kw):
1457 1457 """Generic interface to the inspector system.
1458 1458
1459 1459 This function is meant to be called by pdef, pdoc & friends."""
1460 1460 info = self._object_find(oname)
1461 1461 if info.found:
1462 1462 pmethod = getattr(self.inspector, meth)
1463 1463 formatter = format_screen if info.ismagic else None
1464 1464 if meth == 'pdoc':
1465 1465 pmethod(info.obj, oname, formatter)
1466 1466 elif meth == 'pinfo':
1467 1467 pmethod(info.obj, oname, formatter, info, **kw)
1468 1468 else:
1469 1469 pmethod(info.obj, oname)
1470 1470 else:
1471 1471 print 'Object `%s` not found.' % oname
1472 1472 return 'not found' # so callers can take other action
1473 1473
1474 1474 def object_inspect(self, oname, detail_level=0):
1475 1475 with self.builtin_trap:
1476 1476 info = self._object_find(oname)
1477 1477 if info.found:
1478 1478 return self.inspector.info(info.obj, oname, info=info,
1479 1479 detail_level=detail_level
1480 1480 )
1481 1481 else:
1482 1482 return oinspect.object_info(name=oname, found=False)
1483 1483
1484 1484 #-------------------------------------------------------------------------
1485 1485 # Things related to history management
1486 1486 #-------------------------------------------------------------------------
1487 1487
1488 1488 def init_history(self):
1489 1489 """Sets up the command history, and starts regular autosaves."""
1490 1490 self.history_manager = HistoryManager(shell=self, config=self.config)
1491 1491 self.configurables.append(self.history_manager)
1492 1492
1493 1493 #-------------------------------------------------------------------------
1494 1494 # Things related to exception handling and tracebacks (not debugging)
1495 1495 #-------------------------------------------------------------------------
1496 1496
1497 1497 def init_traceback_handlers(self, custom_exceptions):
1498 1498 # Syntax error handler.
1499 1499 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1500 1500
1501 1501 # The interactive one is initialized with an offset, meaning we always
1502 1502 # want to remove the topmost item in the traceback, which is our own
1503 1503 # internal code. Valid modes: ['Plain','Context','Verbose']
1504 1504 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1505 1505 color_scheme='NoColor',
1506 1506 tb_offset = 1,
1507 1507 check_cache=self.compile.check_cache)
1508 1508
1509 1509 # The instance will store a pointer to the system-wide exception hook,
1510 1510 # so that runtime code (such as magics) can access it. This is because
1511 1511 # during the read-eval loop, it may get temporarily overwritten.
1512 1512 self.sys_excepthook = sys.excepthook
1513 1513
1514 1514 # and add any custom exception handlers the user may have specified
1515 1515 self.set_custom_exc(*custom_exceptions)
1516 1516
1517 1517 # Set the exception mode
1518 1518 self.InteractiveTB.set_mode(mode=self.xmode)
1519 1519
1520 1520 def set_custom_exc(self, exc_tuple, handler):
1521 1521 """set_custom_exc(exc_tuple,handler)
1522 1522
1523 1523 Set a custom exception handler, which will be called if any of the
1524 1524 exceptions in exc_tuple occur in the mainloop (specifically, in the
1525 1525 run_code() method).
1526 1526
1527 1527 Parameters
1528 1528 ----------
1529 1529
1530 1530 exc_tuple : tuple of exception classes
1531 1531 A *tuple* of exception classes, for which to call the defined
1532 1532 handler. It is very important that you use a tuple, and NOT A
1533 1533 LIST here, because of the way Python's except statement works. If
1534 1534 you only want to trap a single exception, use a singleton tuple::
1535 1535
1536 1536 exc_tuple == (MyCustomException,)
1537 1537
1538 1538 handler : callable
1539 1539 handler must have the following signature::
1540 1540
1541 1541 def my_handler(self, etype, value, tb, tb_offset=None):
1542 1542 ...
1543 1543 return structured_traceback
1544 1544
1545 1545 Your handler must return a structured traceback (a list of strings),
1546 1546 or None.
1547 1547
1548 1548 This will be made into an instance method (via types.MethodType)
1549 1549 of IPython itself, and it will be called if any of the exceptions
1550 1550 listed in the exc_tuple are caught. If the handler is None, an
1551 1551 internal basic one is used, which just prints basic info.
1552 1552
1553 1553 To protect IPython from crashes, if your handler ever raises an
1554 1554 exception or returns an invalid result, it will be immediately
1555 1555 disabled.
1556 1556
1557 1557 WARNING: by putting in your own exception handler into IPython's main
1558 1558 execution loop, you run a very good chance of nasty crashes. This
1559 1559 facility should only be used if you really know what you are doing."""
1560 1560
1561 1561 assert type(exc_tuple)==type(()) , \
1562 1562 "The custom exceptions must be given AS A TUPLE."
1563 1563
1564 1564 def dummy_handler(self,etype,value,tb,tb_offset=None):
1565 1565 print '*** Simple custom exception handler ***'
1566 1566 print 'Exception type :',etype
1567 1567 print 'Exception value:',value
1568 1568 print 'Traceback :',tb
1569 1569 #print 'Source code :','\n'.join(self.buffer)
1570 1570
1571 1571 def validate_stb(stb):
1572 1572 """validate structured traceback return type
1573 1573
1574 1574 return type of CustomTB *should* be a list of strings, but allow
1575 1575 single strings or None, which are harmless.
1576 1576
1577 1577 This function will *always* return a list of strings,
1578 1578 and will raise a TypeError if stb is inappropriate.
1579 1579 """
1580 1580 msg = "CustomTB must return list of strings, not %r" % stb
1581 1581 if stb is None:
1582 1582 return []
1583 1583 elif isinstance(stb, basestring):
1584 1584 return [stb]
1585 1585 elif not isinstance(stb, list):
1586 1586 raise TypeError(msg)
1587 1587 # it's a list
1588 1588 for line in stb:
1589 1589 # check every element
1590 1590 if not isinstance(line, basestring):
1591 1591 raise TypeError(msg)
1592 1592 return stb
1593 1593
1594 1594 if handler is None:
1595 1595 wrapped = dummy_handler
1596 1596 else:
1597 1597 def wrapped(self,etype,value,tb,tb_offset=None):
1598 1598 """wrap CustomTB handler, to protect IPython from user code
1599 1599
1600 1600 This makes it harder (but not impossible) for custom exception
1601 1601 handlers to crash IPython.
1602 1602 """
1603 1603 try:
1604 1604 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1605 1605 return validate_stb(stb)
1606 1606 except:
1607 1607 # clear custom handler immediately
1608 1608 self.set_custom_exc((), None)
1609 1609 print >> io.stderr, "Custom TB Handler failed, unregistering"
1610 1610 # show the exception in handler first
1611 1611 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1612 1612 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1613 1613 print >> io.stdout, "The original exception:"
1614 1614 stb = self.InteractiveTB.structured_traceback(
1615 1615 (etype,value,tb), tb_offset=tb_offset
1616 1616 )
1617 1617 return stb
1618 1618
1619 1619 self.CustomTB = types.MethodType(wrapped,self)
1620 1620 self.custom_exceptions = exc_tuple
1621 1621
1622 1622 def excepthook(self, etype, value, tb):
1623 1623 """One more defense for GUI apps that call sys.excepthook.
1624 1624
1625 1625 GUI frameworks like wxPython trap exceptions and call
1626 1626 sys.excepthook themselves. I guess this is a feature that
1627 1627 enables them to keep running after exceptions that would
1628 1628 otherwise kill their mainloop. This is a bother for IPython
1629 1629 which excepts to catch all of the program exceptions with a try:
1630 1630 except: statement.
1631 1631
1632 1632 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1633 1633 any app directly invokes sys.excepthook, it will look to the user like
1634 1634 IPython crashed. In order to work around this, we can disable the
1635 1635 CrashHandler and replace it with this excepthook instead, which prints a
1636 1636 regular traceback using our InteractiveTB. In this fashion, apps which
1637 1637 call sys.excepthook will generate a regular-looking exception from
1638 1638 IPython, and the CrashHandler will only be triggered by real IPython
1639 1639 crashes.
1640 1640
1641 1641 This hook should be used sparingly, only in places which are not likely
1642 1642 to be true IPython errors.
1643 1643 """
1644 1644 self.showtraceback((etype,value,tb),tb_offset=0)
1645 1645
1646 1646 def _get_exc_info(self, exc_tuple=None):
1647 1647 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1648 1648
1649 1649 Ensures sys.last_type,value,traceback hold the exc_info we found,
1650 1650 from whichever source.
1651 1651
1652 1652 raises ValueError if none of these contain any information
1653 1653 """
1654 1654 if exc_tuple is None:
1655 1655 etype, value, tb = sys.exc_info()
1656 1656 else:
1657 1657 etype, value, tb = exc_tuple
1658 1658
1659 1659 if etype is None:
1660 1660 if hasattr(sys, 'last_type'):
1661 1661 etype, value, tb = sys.last_type, sys.last_value, \
1662 1662 sys.last_traceback
1663 1663
1664 1664 if etype is None:
1665 1665 raise ValueError("No exception to find")
1666 1666
1667 1667 # Now store the exception info in sys.last_type etc.
1668 1668 # WARNING: these variables are somewhat deprecated and not
1669 1669 # necessarily safe to use in a threaded environment, but tools
1670 1670 # like pdb depend on their existence, so let's set them. If we
1671 1671 # find problems in the field, we'll need to revisit their use.
1672 1672 sys.last_type = etype
1673 1673 sys.last_value = value
1674 1674 sys.last_traceback = tb
1675 1675
1676 1676 return etype, value, tb
1677 1677
1678 1678
1679 1679 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1680 1680 exception_only=False):
1681 1681 """Display the exception that just occurred.
1682 1682
1683 1683 If nothing is known about the exception, this is the method which
1684 1684 should be used throughout the code for presenting user tracebacks,
1685 1685 rather than directly invoking the InteractiveTB object.
1686 1686
1687 1687 A specific showsyntaxerror() also exists, but this method can take
1688 1688 care of calling it if needed, so unless you are explicitly catching a
1689 1689 SyntaxError exception, don't try to analyze the stack manually and
1690 1690 simply call this method."""
1691 1691
1692 1692 try:
1693 1693 try:
1694 1694 etype, value, tb = self._get_exc_info(exc_tuple)
1695 1695 except ValueError:
1696 1696 self.write_err('No traceback available to show.\n')
1697 1697 return
1698 1698
1699 1699 if etype is SyntaxError:
1700 1700 # Though this won't be called by syntax errors in the input
1701 1701 # line, there may be SyntaxError cases with imported code.
1702 1702 self.showsyntaxerror(filename)
1703 1703 elif etype is UsageError:
1704 1704 self.write_err("UsageError: %s" % value)
1705 1705 else:
1706 1706 if exception_only:
1707 1707 stb = ['An exception has occurred, use %tb to see '
1708 1708 'the full traceback.\n']
1709 1709 stb.extend(self.InteractiveTB.get_exception_only(etype,
1710 1710 value))
1711 1711 else:
1712 1712 stb = self.InteractiveTB.structured_traceback(etype,
1713 1713 value, tb, tb_offset=tb_offset)
1714 1714
1715 1715 self._showtraceback(etype, value, stb)
1716 1716 if self.call_pdb:
1717 1717 # drop into debugger
1718 1718 self.debugger(force=True)
1719 1719 return
1720 1720
1721 1721 # Actually show the traceback
1722 1722 self._showtraceback(etype, value, stb)
1723 1723
1724 1724 except KeyboardInterrupt:
1725 1725 self.write_err("\nKeyboardInterrupt\n")
1726 1726
1727 1727 def _showtraceback(self, etype, evalue, stb):
1728 1728 """Actually show a traceback.
1729 1729
1730 1730 Subclasses may override this method to put the traceback on a different
1731 1731 place, like a side channel.
1732 1732 """
1733 1733 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1734 1734
1735 1735 def showsyntaxerror(self, filename=None):
1736 1736 """Display the syntax error that just occurred.
1737 1737
1738 1738 This doesn't display a stack trace because there isn't one.
1739 1739
1740 1740 If a filename is given, it is stuffed in the exception instead
1741 1741 of what was there before (because Python's parser always uses
1742 1742 "<string>" when reading from a string).
1743 1743 """
1744 1744 etype, value, last_traceback = self._get_exc_info()
1745 1745
1746 1746 if filename and etype is SyntaxError:
1747 1747 try:
1748 1748 value.filename = filename
1749 1749 except:
1750 1750 # Not the format we expect; leave it alone
1751 1751 pass
1752 1752
1753 1753 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1754 1754 self._showtraceback(etype, value, stb)
1755 1755
1756 1756 # This is overridden in TerminalInteractiveShell to show a message about
1757 1757 # the %paste magic.
1758 1758 def showindentationerror(self):
1759 1759 """Called by run_cell when there's an IndentationError in code entered
1760 1760 at the prompt.
1761 1761
1762 1762 This is overridden in TerminalInteractiveShell to show a message about
1763 1763 the %paste magic."""
1764 1764 self.showsyntaxerror()
1765 1765
1766 1766 #-------------------------------------------------------------------------
1767 1767 # Things related to readline
1768 1768 #-------------------------------------------------------------------------
1769 1769
1770 1770 def init_readline(self):
1771 1771 """Command history completion/saving/reloading."""
1772 1772
1773 1773 if self.readline_use:
1774 1774 import IPython.utils.rlineimpl as readline
1775 1775
1776 1776 self.rl_next_input = None
1777 1777 self.rl_do_indent = False
1778 1778
1779 1779 if not self.readline_use or not readline.have_readline:
1780 1780 self.has_readline = False
1781 1781 self.readline = None
1782 1782 # Set a number of methods that depend on readline to be no-op
1783 1783 self.readline_no_record = no_op_context
1784 1784 self.set_readline_completer = no_op
1785 1785 self.set_custom_completer = no_op
1786 1786 self.set_completer_frame = no_op
1787 1787 if self.readline_use:
1788 1788 warn('Readline services not available or not loaded.')
1789 1789 else:
1790 1790 self.has_readline = True
1791 1791 self.readline = readline
1792 1792 sys.modules['readline'] = readline
1793 1793
1794 1794 # Platform-specific configuration
1795 1795 if os.name == 'nt':
1796 1796 # FIXME - check with Frederick to see if we can harmonize
1797 1797 # naming conventions with pyreadline to avoid this
1798 1798 # platform-dependent check
1799 1799 self.readline_startup_hook = readline.set_pre_input_hook
1800 1800 else:
1801 1801 self.readline_startup_hook = readline.set_startup_hook
1802 1802
1803 1803 # Load user's initrc file (readline config)
1804 1804 # Or if libedit is used, load editrc.
1805 1805 inputrc_name = os.environ.get('INPUTRC')
1806 1806 if inputrc_name is None:
1807 1807 inputrc_name = '.inputrc'
1808 1808 if readline.uses_libedit:
1809 1809 inputrc_name = '.editrc'
1810 1810 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1811 1811 if os.path.isfile(inputrc_name):
1812 1812 try:
1813 1813 readline.read_init_file(inputrc_name)
1814 1814 except:
1815 1815 warn('Problems reading readline initialization file <%s>'
1816 1816 % inputrc_name)
1817 1817
1818 1818 # Configure readline according to user's prefs
1819 1819 # This is only done if GNU readline is being used. If libedit
1820 1820 # is being used (as on Leopard) the readline config is
1821 1821 # not run as the syntax for libedit is different.
1822 1822 if not readline.uses_libedit:
1823 1823 for rlcommand in self.readline_parse_and_bind:
1824 1824 #print "loading rl:",rlcommand # dbg
1825 1825 readline.parse_and_bind(rlcommand)
1826 1826
1827 1827 # Remove some chars from the delimiters list. If we encounter
1828 1828 # unicode chars, discard them.
1829 1829 delims = readline.get_completer_delims()
1830 1830 if not py3compat.PY3:
1831 1831 delims = delims.encode("ascii", "ignore")
1832 1832 for d in self.readline_remove_delims:
1833 1833 delims = delims.replace(d, "")
1834 1834 delims = delims.replace(ESC_MAGIC, '')
1835 1835 readline.set_completer_delims(delims)
1836 1836 # otherwise we end up with a monster history after a while:
1837 1837 readline.set_history_length(self.history_length)
1838 1838
1839 1839 self.refill_readline_hist()
1840 1840 self.readline_no_record = ReadlineNoRecord(self)
1841 1841
1842 1842 # Configure auto-indent for all platforms
1843 1843 self.set_autoindent(self.autoindent)
1844 1844
1845 1845 def refill_readline_hist(self):
1846 1846 # Load the last 1000 lines from history
1847 1847 self.readline.clear_history()
1848 1848 stdin_encoding = sys.stdin.encoding or "utf-8"
1849 1849 last_cell = u""
1850 1850 for _, _, cell in self.history_manager.get_tail(1000,
1851 1851 include_latest=True):
1852 1852 # Ignore blank lines and consecutive duplicates
1853 1853 cell = cell.rstrip()
1854 1854 if cell and (cell != last_cell):
1855 1855 if self.multiline_history:
1856 1856 self.readline.add_history(py3compat.unicode_to_str(cell,
1857 1857 stdin_encoding))
1858 1858 else:
1859 1859 for line in cell.splitlines():
1860 1860 self.readline.add_history(py3compat.unicode_to_str(line,
1861 1861 stdin_encoding))
1862 1862 last_cell = cell
1863 1863
1864 1864 def set_next_input(self, s):
1865 1865 """ Sets the 'default' input string for the next command line.
1866 1866
1867 1867 Requires readline.
1868 1868
1869 1869 Example:
1870 1870
1871 1871 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1872 1872 [D:\ipython]|2> Hello Word_ # cursor is here
1873 1873 """
1874 1874 self.rl_next_input = py3compat.cast_bytes_py2(s)
1875 1875
1876 1876 # Maybe move this to the terminal subclass?
1877 1877 def pre_readline(self):
1878 1878 """readline hook to be used at the start of each line.
1879 1879
1880 1880 Currently it handles auto-indent only."""
1881 1881
1882 1882 if self.rl_do_indent:
1883 1883 self.readline.insert_text(self._indent_current_str())
1884 1884 if self.rl_next_input is not None:
1885 1885 self.readline.insert_text(self.rl_next_input)
1886 1886 self.rl_next_input = None
1887 1887
1888 1888 def _indent_current_str(self):
1889 1889 """return the current level of indentation as a string"""
1890 1890 return self.input_splitter.indent_spaces * ' '
1891 1891
1892 1892 #-------------------------------------------------------------------------
1893 1893 # Things related to text completion
1894 1894 #-------------------------------------------------------------------------
1895 1895
1896 1896 def init_completer(self):
1897 1897 """Initialize the completion machinery.
1898 1898
1899 1899 This creates completion machinery that can be used by client code,
1900 1900 either interactively in-process (typically triggered by the readline
1901 1901 library), programatically (such as in test suites) or out-of-prcess
1902 1902 (typically over the network by remote frontends).
1903 1903 """
1904 1904 from IPython.core.completer import IPCompleter
1905 1905 from IPython.core.completerlib import (module_completer,
1906 1906 magic_run_completer, cd_completer, reset_completer)
1907 1907
1908 1908 self.Completer = IPCompleter(shell=self,
1909 1909 namespace=self.user_ns,
1910 1910 global_namespace=self.user_global_ns,
1911 1911 alias_table=self.alias_manager.alias_table,
1912 1912 use_readline=self.has_readline,
1913 1913 config=self.config,
1914 1914 )
1915 1915 self.configurables.append(self.Completer)
1916 1916
1917 1917 # Add custom completers to the basic ones built into IPCompleter
1918 1918 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1919 1919 self.strdispatchers['complete_command'] = sdisp
1920 1920 self.Completer.custom_completers = sdisp
1921 1921
1922 1922 self.set_hook('complete_command', module_completer, str_key = 'import')
1923 1923 self.set_hook('complete_command', module_completer, str_key = 'from')
1924 1924 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1925 1925 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1926 1926 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1927 1927
1928 1928 # Only configure readline if we truly are using readline. IPython can
1929 1929 # do tab-completion over the network, in GUIs, etc, where readline
1930 1930 # itself may be absent
1931 1931 if self.has_readline:
1932 1932 self.set_readline_completer()
1933 1933
1934 1934 def complete(self, text, line=None, cursor_pos=None):
1935 1935 """Return the completed text and a list of completions.
1936 1936
1937 1937 Parameters
1938 1938 ----------
1939 1939
1940 1940 text : string
1941 1941 A string of text to be completed on. It can be given as empty and
1942 1942 instead a line/position pair are given. In this case, the
1943 1943 completer itself will split the line like readline does.
1944 1944
1945 1945 line : string, optional
1946 1946 The complete line that text is part of.
1947 1947
1948 1948 cursor_pos : int, optional
1949 1949 The position of the cursor on the input line.
1950 1950
1951 1951 Returns
1952 1952 -------
1953 1953 text : string
1954 1954 The actual text that was completed.
1955 1955
1956 1956 matches : list
1957 1957 A sorted list with all possible completions.
1958 1958
1959 1959 The optional arguments allow the completion to take more context into
1960 1960 account, and are part of the low-level completion API.
1961 1961
1962 1962 This is a wrapper around the completion mechanism, similar to what
1963 1963 readline does at the command line when the TAB key is hit. By
1964 1964 exposing it as a method, it can be used by other non-readline
1965 1965 environments (such as GUIs) for text completion.
1966 1966
1967 1967 Simple usage example:
1968 1968
1969 1969 In [1]: x = 'hello'
1970 1970
1971 1971 In [2]: _ip.complete('x.l')
1972 1972 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1973 1973 """
1974 1974
1975 1975 # Inject names into __builtin__ so we can complete on the added names.
1976 1976 with self.builtin_trap:
1977 1977 return self.Completer.complete(text, line, cursor_pos)
1978 1978
1979 1979 def set_custom_completer(self, completer, pos=0):
1980 1980 """Adds a new custom completer function.
1981 1981
1982 1982 The position argument (defaults to 0) is the index in the completers
1983 1983 list where you want the completer to be inserted."""
1984 1984
1985 1985 newcomp = types.MethodType(completer,self.Completer)
1986 1986 self.Completer.matchers.insert(pos,newcomp)
1987 1987
1988 1988 def set_readline_completer(self):
1989 1989 """Reset readline's completer to be our own."""
1990 1990 self.readline.set_completer(self.Completer.rlcomplete)
1991 1991
1992 1992 def set_completer_frame(self, frame=None):
1993 1993 """Set the frame of the completer."""
1994 1994 if frame:
1995 1995 self.Completer.namespace = frame.f_locals
1996 1996 self.Completer.global_namespace = frame.f_globals
1997 1997 else:
1998 1998 self.Completer.namespace = self.user_ns
1999 1999 self.Completer.global_namespace = self.user_global_ns
2000 2000
2001 2001 #-------------------------------------------------------------------------
2002 2002 # Things related to magics
2003 2003 #-------------------------------------------------------------------------
2004 2004
2005 2005 def init_magics(self):
2006 2006 from IPython.core import magics as m
2007 2007 self.magics_manager = magic.MagicsManager(shell=self,
2008 2008 confg=self.config,
2009 2009 user_magics=m.UserMagics(self))
2010 2010 self.configurables.append(self.magics_manager)
2011 2011
2012 2012 # Expose as public API from the magics manager
2013 2013 self.register_magics = self.magics_manager.register
2014 2014 self.register_magic_function = self.magics_manager.register_function
2015 2015 self.define_magic = self.magics_manager.define_magic
2016 2016
2017 2017 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2018 2018 m.ConfigMagics, m.DeprecatedMagics, m.ExecutionMagics,
2019 2019 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2020 m.NamespaceMagics, m.OSMagics, m.PylabMagics )
2020 m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
2021 )
2021 2022
2022 2023 # FIXME: Move the color initialization to the DisplayHook, which
2023 2024 # should be split into a prompt manager and displayhook. We probably
2024 2025 # even need a centralize colors management object.
2025 2026 self.magic('colors %s' % self.colors)
2026 2027
2027 2028 def run_line_magic(self, magic_name, line):
2028 2029 """Execute the given line magic.
2029 2030
2030 2031 Parameters
2031 2032 ----------
2032 2033 magic_name : str
2033 2034 Name of the desired magic function, without '%' prefix.
2034 2035
2035 2036 line : str
2036 2037 The rest of the input line as a single string.
2037 2038 """
2038 2039 fn = self.find_line_magic(magic_name)
2039 2040 if fn is None:
2040 2041 cm = self.find_cell_magic(magic_name)
2041 2042 etpl = "Line magic function `%%%s` not found%s."
2042 2043 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2043 2044 'did you mean that instead?)' % magic_name )
2044 2045 error(etpl % (magic_name, extra))
2045 2046 else:
2046 2047 # Note: this is the distance in the stack to the user's frame.
2047 2048 # This will need to be updated if the internal calling logic gets
2048 2049 # refactored, or else we'll be expanding the wrong variables.
2049 2050 stack_depth = 2
2050 2051 magic_arg_s = self.var_expand(line, stack_depth)
2051 2052 # Put magic args in a list so we can call with f(*a) syntax
2052 2053 args = [magic_arg_s]
2053 2054 # Grab local namespace if we need it:
2054 2055 if getattr(fn, "needs_local_scope", False):
2055 2056 args.append(sys._getframe(stack_depth).f_locals)
2056 2057 with self.builtin_trap:
2057 2058 result = fn(*args)
2058 2059 return result
2059 2060
2060 2061 def run_cell_magic(self, magic_name, line, cell):
2061 2062 """Execute the given cell magic.
2062 2063
2063 2064 Parameters
2064 2065 ----------
2065 2066 magic_name : str
2066 2067 Name of the desired magic function, without '%' prefix.
2067 2068
2068 2069 line : str
2069 2070 The rest of the first input line as a single string.
2070 2071
2071 2072 cell : str
2072 2073 The body of the cell as a (possibly multiline) string.
2073 2074 """
2074 2075 fn = self.find_cell_magic(magic_name)
2075 2076 if fn is None:
2076 2077 lm = self.find_line_magic(magic_name)
2077 2078 etpl = "Cell magic function `%%%%%s` not found%s."
2078 2079 extra = '' if lm is None else (' (But line magic `%%%s` exists, '
2079 2080 'did you mean that instead?)' % magic_name )
2080 2081 error(etpl % (magic_name, extra))
2081 2082 else:
2082 2083 # Note: this is the distance in the stack to the user's frame.
2083 2084 # This will need to be updated if the internal calling logic gets
2084 2085 # refactored, or else we'll be expanding the wrong variables.
2085 2086 stack_depth = 2
2086 2087 magic_arg_s = self.var_expand(line, stack_depth)
2087 2088 with self.builtin_trap:
2088 2089 result = fn(line, cell)
2089 2090 return result
2090 2091
2091 2092 def find_line_magic(self, magic_name):
2092 2093 """Find and return a line magic by name.
2093 2094
2094 2095 Returns None if the magic isn't found."""
2095 2096 return self.magics_manager.magics['line'].get(magic_name)
2096 2097
2097 2098 def find_cell_magic(self, magic_name):
2098 2099 """Find and return a cell magic by name.
2099 2100
2100 2101 Returns None if the magic isn't found."""
2101 2102 return self.magics_manager.magics['cell'].get(magic_name)
2102 2103
2103 2104 def find_magic(self, magic_name, magic_kind='line'):
2104 2105 """Find and return a magic of the given type by name.
2105 2106
2106 2107 Returns None if the magic isn't found."""
2107 2108 return self.magics_manager.magics[magic_kind].get(magic_name)
2108 2109
2109 2110 def magic(self, arg_s):
2110 2111 """DEPRECATED. Use run_line_magic() instead.
2111 2112
2112 2113 Call a magic function by name.
2113 2114
2114 2115 Input: a string containing the name of the magic function to call and
2115 2116 any additional arguments to be passed to the magic.
2116 2117
2117 2118 magic('name -opt foo bar') is equivalent to typing at the ipython
2118 2119 prompt:
2119 2120
2120 2121 In[1]: %name -opt foo bar
2121 2122
2122 2123 To call a magic without arguments, simply use magic('name').
2123 2124
2124 2125 This provides a proper Python function to call IPython's magics in any
2125 2126 valid Python code you can type at the interpreter, including loops and
2126 2127 compound statements.
2127 2128 """
2128 2129 # TODO: should we issue a loud deprecation warning here?
2129 2130 magic_name, _, magic_arg_s = arg_s.partition(' ')
2130 2131 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2131 2132 return self.run_line_magic(magic_name, magic_arg_s)
2132 2133
2133 2134 #-------------------------------------------------------------------------
2134 2135 # Things related to macros
2135 2136 #-------------------------------------------------------------------------
2136 2137
2137 2138 def define_macro(self, name, themacro):
2138 2139 """Define a new macro
2139 2140
2140 2141 Parameters
2141 2142 ----------
2142 2143 name : str
2143 2144 The name of the macro.
2144 2145 themacro : str or Macro
2145 2146 The action to do upon invoking the macro. If a string, a new
2146 2147 Macro object is created by passing the string to it.
2147 2148 """
2148 2149
2149 2150 from IPython.core import macro
2150 2151
2151 2152 if isinstance(themacro, basestring):
2152 2153 themacro = macro.Macro(themacro)
2153 2154 if not isinstance(themacro, macro.Macro):
2154 2155 raise ValueError('A macro must be a string or a Macro instance.')
2155 2156 self.user_ns[name] = themacro
2156 2157
2157 2158 #-------------------------------------------------------------------------
2158 2159 # Things related to the running of system commands
2159 2160 #-------------------------------------------------------------------------
2160 2161
2161 2162 def system_piped(self, cmd):
2162 2163 """Call the given cmd in a subprocess, piping stdout/err
2163 2164
2164 2165 Parameters
2165 2166 ----------
2166 2167 cmd : str
2167 2168 Command to execute (can not end in '&', as background processes are
2168 2169 not supported. Should not be a command that expects input
2169 2170 other than simple text.
2170 2171 """
2171 2172 if cmd.rstrip().endswith('&'):
2172 2173 # this is *far* from a rigorous test
2173 2174 # We do not support backgrounding processes because we either use
2174 2175 # pexpect or pipes to read from. Users can always just call
2175 2176 # os.system() or use ip.system=ip.system_raw
2176 2177 # if they really want a background process.
2177 2178 raise OSError("Background processes not supported.")
2178 2179
2179 2180 # we explicitly do NOT return the subprocess status code, because
2180 2181 # a non-None value would trigger :func:`sys.displayhook` calls.
2181 2182 # Instead, we store the exit_code in user_ns.
2182 2183 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
2183 2184
2184 2185 def system_raw(self, cmd):
2185 2186 """Call the given cmd in a subprocess using os.system
2186 2187
2187 2188 Parameters
2188 2189 ----------
2189 2190 cmd : str
2190 2191 Command to execute.
2191 2192 """
2192 2193 cmd = self.var_expand(cmd, depth=2)
2193 2194 # protect os.system from UNC paths on Windows, which it can't handle:
2194 2195 if sys.platform == 'win32':
2195 2196 from IPython.utils._process_win32 import AvoidUNCPath
2196 2197 with AvoidUNCPath() as path:
2197 2198 if path is not None:
2198 2199 cmd = '"pushd %s &&"%s' % (path, cmd)
2199 2200 cmd = py3compat.unicode_to_str(cmd)
2200 2201 ec = os.system(cmd)
2201 2202 else:
2202 2203 cmd = py3compat.unicode_to_str(cmd)
2203 2204 ec = os.system(cmd)
2204 2205
2205 2206 # We explicitly do NOT return the subprocess status code, because
2206 2207 # a non-None value would trigger :func:`sys.displayhook` calls.
2207 2208 # Instead, we store the exit_code in user_ns.
2208 2209 self.user_ns['_exit_code'] = ec
2209 2210
2210 2211 # use piped system by default, because it is better behaved
2211 2212 system = system_piped
2212 2213
2213 2214 def getoutput(self, cmd, split=True):
2214 2215 """Get output (possibly including stderr) from a subprocess.
2215 2216
2216 2217 Parameters
2217 2218 ----------
2218 2219 cmd : str
2219 2220 Command to execute (can not end in '&', as background processes are
2220 2221 not supported.
2221 2222 split : bool, optional
2222 2223
2223 2224 If True, split the output into an IPython SList. Otherwise, an
2224 2225 IPython LSString is returned. These are objects similar to normal
2225 2226 lists and strings, with a few convenience attributes for easier
2226 2227 manipulation of line-based output. You can use '?' on them for
2227 2228 details.
2228 2229 """
2229 2230 if cmd.rstrip().endswith('&'):
2230 2231 # this is *far* from a rigorous test
2231 2232 raise OSError("Background processes not supported.")
2232 2233 out = getoutput(self.var_expand(cmd, depth=2))
2233 2234 if split:
2234 2235 out = SList(out.splitlines())
2235 2236 else:
2236 2237 out = LSString(out)
2237 2238 return out
2238 2239
2239 2240 #-------------------------------------------------------------------------
2240 2241 # Things related to aliases
2241 2242 #-------------------------------------------------------------------------
2242 2243
2243 2244 def init_alias(self):
2244 2245 self.alias_manager = AliasManager(shell=self, config=self.config)
2245 2246 self.configurables.append(self.alias_manager)
2246 2247 self.ns_table['alias'] = self.alias_manager.alias_table,
2247 2248
2248 2249 #-------------------------------------------------------------------------
2249 2250 # Things related to extensions and plugins
2250 2251 #-------------------------------------------------------------------------
2251 2252
2252 2253 def init_extension_manager(self):
2253 2254 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2254 2255 self.configurables.append(self.extension_manager)
2255 2256
2256 2257 def init_plugin_manager(self):
2257 2258 self.plugin_manager = PluginManager(config=self.config)
2258 2259 self.configurables.append(self.plugin_manager)
2259 2260
2260 2261
2261 2262 #-------------------------------------------------------------------------
2262 2263 # Things related to payloads
2263 2264 #-------------------------------------------------------------------------
2264 2265
2265 2266 def init_payload(self):
2266 2267 self.payload_manager = PayloadManager(config=self.config)
2267 2268 self.configurables.append(self.payload_manager)
2268 2269
2269 2270 #-------------------------------------------------------------------------
2270 2271 # Things related to the prefilter
2271 2272 #-------------------------------------------------------------------------
2272 2273
2273 2274 def init_prefilter(self):
2274 2275 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2275 2276 self.configurables.append(self.prefilter_manager)
2276 2277 # Ultimately this will be refactored in the new interpreter code, but
2277 2278 # for now, we should expose the main prefilter method (there's legacy
2278 2279 # code out there that may rely on this).
2279 2280 self.prefilter = self.prefilter_manager.prefilter_lines
2280 2281
2281 2282 def auto_rewrite_input(self, cmd):
2282 2283 """Print to the screen the rewritten form of the user's command.
2283 2284
2284 2285 This shows visual feedback by rewriting input lines that cause
2285 2286 automatic calling to kick in, like::
2286 2287
2287 2288 /f x
2288 2289
2289 2290 into::
2290 2291
2291 2292 ------> f(x)
2292 2293
2293 2294 after the user's input prompt. This helps the user understand that the
2294 2295 input line was transformed automatically by IPython.
2295 2296 """
2296 2297 if not self.show_rewritten_input:
2297 2298 return
2298 2299
2299 2300 rw = self.prompt_manager.render('rewrite') + cmd
2300 2301
2301 2302 try:
2302 2303 # plain ascii works better w/ pyreadline, on some machines, so
2303 2304 # we use it and only print uncolored rewrite if we have unicode
2304 2305 rw = str(rw)
2305 2306 print >> io.stdout, rw
2306 2307 except UnicodeEncodeError:
2307 2308 print "------> " + cmd
2308 2309
2309 2310 #-------------------------------------------------------------------------
2310 2311 # Things related to extracting values/expressions from kernel and user_ns
2311 2312 #-------------------------------------------------------------------------
2312 2313
2313 2314 def _simple_error(self):
2314 2315 etype, value = sys.exc_info()[:2]
2315 2316 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2316 2317
2317 2318 def user_variables(self, names):
2318 2319 """Get a list of variable names from the user's namespace.
2319 2320
2320 2321 Parameters
2321 2322 ----------
2322 2323 names : list of strings
2323 2324 A list of names of variables to be read from the user namespace.
2324 2325
2325 2326 Returns
2326 2327 -------
2327 2328 A dict, keyed by the input names and with the repr() of each value.
2328 2329 """
2329 2330 out = {}
2330 2331 user_ns = self.user_ns
2331 2332 for varname in names:
2332 2333 try:
2333 2334 value = repr(user_ns[varname])
2334 2335 except:
2335 2336 value = self._simple_error()
2336 2337 out[varname] = value
2337 2338 return out
2338 2339
2339 2340 def user_expressions(self, expressions):
2340 2341 """Evaluate a dict of expressions in the user's namespace.
2341 2342
2342 2343 Parameters
2343 2344 ----------
2344 2345 expressions : dict
2345 2346 A dict with string keys and string values. The expression values
2346 2347 should be valid Python expressions, each of which will be evaluated
2347 2348 in the user namespace.
2348 2349
2349 2350 Returns
2350 2351 -------
2351 2352 A dict, keyed like the input expressions dict, with the repr() of each
2352 2353 value.
2353 2354 """
2354 2355 out = {}
2355 2356 user_ns = self.user_ns
2356 2357 global_ns = self.user_global_ns
2357 2358 for key, expr in expressions.iteritems():
2358 2359 try:
2359 2360 value = repr(eval(expr, global_ns, user_ns))
2360 2361 except:
2361 2362 value = self._simple_error()
2362 2363 out[key] = value
2363 2364 return out
2364 2365
2365 2366 #-------------------------------------------------------------------------
2366 2367 # Things related to the running of code
2367 2368 #-------------------------------------------------------------------------
2368 2369
2369 2370 def ex(self, cmd):
2370 2371 """Execute a normal python statement in user namespace."""
2371 2372 with self.builtin_trap:
2372 2373 exec cmd in self.user_global_ns, self.user_ns
2373 2374
2374 2375 def ev(self, expr):
2375 2376 """Evaluate python expression expr in user namespace.
2376 2377
2377 2378 Returns the result of evaluation
2378 2379 """
2379 2380 with self.builtin_trap:
2380 2381 return eval(expr, self.user_global_ns, self.user_ns)
2381 2382
2382 2383 def safe_execfile(self, fname, *where, **kw):
2383 2384 """A safe version of the builtin execfile().
2384 2385
2385 2386 This version will never throw an exception, but instead print
2386 2387 helpful error messages to the screen. This only works on pure
2387 2388 Python files with the .py extension.
2388 2389
2389 2390 Parameters
2390 2391 ----------
2391 2392 fname : string
2392 2393 The name of the file to be executed.
2393 2394 where : tuple
2394 2395 One or two namespaces, passed to execfile() as (globals,locals).
2395 2396 If only one is given, it is passed as both.
2396 2397 exit_ignore : bool (False)
2397 2398 If True, then silence SystemExit for non-zero status (it is always
2398 2399 silenced for zero status, as it is so common).
2399 2400 raise_exceptions : bool (False)
2400 2401 If True raise exceptions everywhere. Meant for testing.
2401 2402
2402 2403 """
2403 2404 kw.setdefault('exit_ignore', False)
2404 2405 kw.setdefault('raise_exceptions', False)
2405 2406
2406 2407 fname = os.path.abspath(os.path.expanduser(fname))
2407 2408
2408 2409 # Make sure we can open the file
2409 2410 try:
2410 2411 with open(fname) as thefile:
2411 2412 pass
2412 2413 except:
2413 2414 warn('Could not open file <%s> for safe execution.' % fname)
2414 2415 return
2415 2416
2416 2417 # Find things also in current directory. This is needed to mimic the
2417 2418 # behavior of running a script from the system command line, where
2418 2419 # Python inserts the script's directory into sys.path
2419 2420 dname = os.path.dirname(fname)
2420 2421
2421 2422 with prepended_to_syspath(dname):
2422 2423 try:
2423 2424 py3compat.execfile(fname,*where)
2424 2425 except SystemExit, status:
2425 2426 # If the call was made with 0 or None exit status (sys.exit(0)
2426 2427 # or sys.exit() ), don't bother showing a traceback, as both of
2427 2428 # these are considered normal by the OS:
2428 2429 # > python -c'import sys;sys.exit(0)'; echo $?
2429 2430 # 0
2430 2431 # > python -c'import sys;sys.exit()'; echo $?
2431 2432 # 0
2432 2433 # For other exit status, we show the exception unless
2433 2434 # explicitly silenced, but only in short form.
2434 2435 if kw['raise_exceptions']:
2435 2436 raise
2436 2437 if status.code not in (0, None) and not kw['exit_ignore']:
2437 2438 self.showtraceback(exception_only=True)
2438 2439 except:
2439 2440 if kw['raise_exceptions']:
2440 2441 raise
2441 2442 self.showtraceback()
2442 2443
2443 2444 def safe_execfile_ipy(self, fname):
2444 2445 """Like safe_execfile, but for .ipy files with IPython syntax.
2445 2446
2446 2447 Parameters
2447 2448 ----------
2448 2449 fname : str
2449 2450 The name of the file to execute. The filename must have a
2450 2451 .ipy extension.
2451 2452 """
2452 2453 fname = os.path.abspath(os.path.expanduser(fname))
2453 2454
2454 2455 # Make sure we can open the file
2455 2456 try:
2456 2457 with open(fname) as thefile:
2457 2458 pass
2458 2459 except:
2459 2460 warn('Could not open file <%s> for safe execution.' % fname)
2460 2461 return
2461 2462
2462 2463 # Find things also in current directory. This is needed to mimic the
2463 2464 # behavior of running a script from the system command line, where
2464 2465 # Python inserts the script's directory into sys.path
2465 2466 dname = os.path.dirname(fname)
2466 2467
2467 2468 with prepended_to_syspath(dname):
2468 2469 try:
2469 2470 with open(fname) as thefile:
2470 2471 # self.run_cell currently captures all exceptions
2471 2472 # raised in user code. It would be nice if there were
2472 2473 # versions of runlines, execfile that did raise, so
2473 2474 # we could catch the errors.
2474 2475 self.run_cell(thefile.read(), store_history=False)
2475 2476 except:
2476 2477 self.showtraceback()
2477 2478 warn('Unknown failure executing file: <%s>' % fname)
2478 2479
2479 2480 def safe_run_module(self, mod_name, where):
2480 2481 """A safe version of runpy.run_module().
2481 2482
2482 2483 This version will never throw an exception, but instead print
2483 2484 helpful error messages to the screen.
2484 2485
2485 2486 Parameters
2486 2487 ----------
2487 2488 mod_name : string
2488 2489 The name of the module to be executed.
2489 2490 where : dict
2490 2491 The globals namespace.
2491 2492 """
2492 2493 try:
2493 2494 where.update(
2494 2495 runpy.run_module(str(mod_name), run_name="__main__",
2495 2496 alter_sys=True)
2496 2497 )
2497 2498 except:
2498 2499 self.showtraceback()
2499 2500 warn('Unknown failure executing module: <%s>' % mod_name)
2500 2501
2501 2502 def _run_cached_cell_magic(self, magic_name, line):
2502 2503 """Special method to call a cell magic with the data stored in self.
2503 2504 """
2504 2505 cell = self._current_cell_magic_body
2505 2506 self._current_cell_magic_body = None
2506 2507 return self.run_cell_magic(magic_name, line, cell)
2507 2508
2508 2509 def run_cell(self, raw_cell, store_history=False, silent=False):
2509 2510 """Run a complete IPython cell.
2510 2511
2511 2512 Parameters
2512 2513 ----------
2513 2514 raw_cell : str
2514 2515 The code (including IPython code such as %magic functions) to run.
2515 2516 store_history : bool
2516 2517 If True, the raw and translated cell will be stored in IPython's
2517 2518 history. For user code calling back into IPython's machinery, this
2518 2519 should be set to False.
2519 2520 silent : bool
2520 2521 If True, avoid side-effets, such as implicit displayhooks, history,
2521 2522 and logging. silent=True forces store_history=False.
2522 2523 """
2523 2524 if (not raw_cell) or raw_cell.isspace():
2524 2525 return
2525 2526
2526 2527 if silent:
2527 2528 store_history = False
2528 2529
2529 2530 self.input_splitter.push(raw_cell)
2530 2531
2531 2532 # Check for cell magics, which leave state behind. This interface is
2532 2533 # ugly, we need to do something cleaner later... Now the logic is
2533 2534 # simply that the input_splitter remembers if there was a cell magic,
2534 2535 # and in that case we grab the cell body.
2535 2536 if self.input_splitter.cell_magic_parts:
2536 2537 self._current_cell_magic_body = \
2537 2538 ''.join(self.input_splitter.cell_magic_parts)
2538 2539 cell = self.input_splitter.source_reset()
2539 2540
2540 2541 with self.builtin_trap:
2541 2542 prefilter_failed = False
2542 2543 if len(cell.splitlines()) == 1:
2543 2544 try:
2544 2545 # use prefilter_lines to handle trailing newlines
2545 2546 # restore trailing newline for ast.parse
2546 2547 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2547 2548 except AliasError as e:
2548 2549 error(e)
2549 2550 prefilter_failed = True
2550 2551 except Exception:
2551 2552 # don't allow prefilter errors to crash IPython
2552 2553 self.showtraceback()
2553 2554 prefilter_failed = True
2554 2555
2555 2556 # Store raw and processed history
2556 2557 if store_history:
2557 2558 self.history_manager.store_inputs(self.execution_count,
2558 2559 cell, raw_cell)
2559 2560 if not silent:
2560 2561 self.logger.log(cell, raw_cell)
2561 2562
2562 2563 if not prefilter_failed:
2563 2564 # don't run if prefilter failed
2564 2565 cell_name = self.compile.cache(cell, self.execution_count)
2565 2566
2566 2567 with self.display_trap:
2567 2568 try:
2568 2569 code_ast = self.compile.ast_parse(cell,
2569 2570 filename=cell_name)
2570 2571 except IndentationError:
2571 2572 self.showindentationerror()
2572 2573 if store_history:
2573 2574 self.execution_count += 1
2574 2575 return None
2575 2576 except (OverflowError, SyntaxError, ValueError, TypeError,
2576 2577 MemoryError):
2577 2578 self.showsyntaxerror()
2578 2579 if store_history:
2579 2580 self.execution_count += 1
2580 2581 return None
2581 2582
2582 2583 interactivity = "none" if silent else self.ast_node_interactivity
2583 2584 self.run_ast_nodes(code_ast.body, cell_name,
2584 2585 interactivity=interactivity)
2585 2586
2586 2587 # Execute any registered post-execution functions.
2587 2588 # unless we are silent
2588 2589 post_exec = [] if silent else self._post_execute.iteritems()
2589 2590
2590 2591 for func, status in post_exec:
2591 2592 if self.disable_failing_post_execute and not status:
2592 2593 continue
2593 2594 try:
2594 2595 func()
2595 2596 except KeyboardInterrupt:
2596 2597 print >> io.stderr, "\nKeyboardInterrupt"
2597 2598 except Exception:
2598 2599 # register as failing:
2599 2600 self._post_execute[func] = False
2600 2601 self.showtraceback()
2601 2602 print >> io.stderr, '\n'.join([
2602 2603 "post-execution function %r produced an error." % func,
2603 2604 "If this problem persists, you can disable failing post-exec functions with:",
2604 2605 "",
2605 2606 " get_ipython().disable_failing_post_execute = True"
2606 2607 ])
2607 2608
2608 2609 if store_history:
2609 2610 # Write output to the database. Does nothing unless
2610 2611 # history output logging is enabled.
2611 2612 self.history_manager.store_output(self.execution_count)
2612 2613 # Each cell is a *single* input, regardless of how many lines it has
2613 2614 self.execution_count += 1
2614 2615
2615 2616 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2616 2617 """Run a sequence of AST nodes. The execution mode depends on the
2617 2618 interactivity parameter.
2618 2619
2619 2620 Parameters
2620 2621 ----------
2621 2622 nodelist : list
2622 2623 A sequence of AST nodes to run.
2623 2624 cell_name : str
2624 2625 Will be passed to the compiler as the filename of the cell. Typically
2625 2626 the value returned by ip.compile.cache(cell).
2626 2627 interactivity : str
2627 2628 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2628 2629 run interactively (displaying output from expressions). 'last_expr'
2629 2630 will run the last node interactively only if it is an expression (i.e.
2630 2631 expressions in loops or other blocks are not displayed. Other values
2631 2632 for this parameter will raise a ValueError.
2632 2633 """
2633 2634 if not nodelist:
2634 2635 return
2635 2636
2636 2637 if interactivity == 'last_expr':
2637 2638 if isinstance(nodelist[-1], ast.Expr):
2638 2639 interactivity = "last"
2639 2640 else:
2640 2641 interactivity = "none"
2641 2642
2642 2643 if interactivity == 'none':
2643 2644 to_run_exec, to_run_interactive = nodelist, []
2644 2645 elif interactivity == 'last':
2645 2646 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2646 2647 elif interactivity == 'all':
2647 2648 to_run_exec, to_run_interactive = [], nodelist
2648 2649 else:
2649 2650 raise ValueError("Interactivity was %r" % interactivity)
2650 2651
2651 2652 exec_count = self.execution_count
2652 2653
2653 2654 try:
2654 2655 for i, node in enumerate(to_run_exec):
2655 2656 mod = ast.Module([node])
2656 2657 code = self.compile(mod, cell_name, "exec")
2657 2658 if self.run_code(code):
2658 2659 return True
2659 2660
2660 2661 for i, node in enumerate(to_run_interactive):
2661 2662 mod = ast.Interactive([node])
2662 2663 code = self.compile(mod, cell_name, "single")
2663 2664 if self.run_code(code):
2664 2665 return True
2665 2666
2666 2667 # Flush softspace
2667 2668 if softspace(sys.stdout, 0):
2668 2669 print
2669 2670
2670 2671 except:
2671 2672 # It's possible to have exceptions raised here, typically by
2672 2673 # compilation of odd code (such as a naked 'return' outside a
2673 2674 # function) that did parse but isn't valid. Typically the exception
2674 2675 # is a SyntaxError, but it's safest just to catch anything and show
2675 2676 # the user a traceback.
2676 2677
2677 2678 # We do only one try/except outside the loop to minimize the impact
2678 2679 # on runtime, and also because if any node in the node list is
2679 2680 # broken, we should stop execution completely.
2680 2681 self.showtraceback()
2681 2682
2682 2683 return False
2683 2684
2684 2685 def run_code(self, code_obj):
2685 2686 """Execute a code object.
2686 2687
2687 2688 When an exception occurs, self.showtraceback() is called to display a
2688 2689 traceback.
2689 2690
2690 2691 Parameters
2691 2692 ----------
2692 2693 code_obj : code object
2693 2694 A compiled code object, to be executed
2694 2695
2695 2696 Returns
2696 2697 -------
2697 2698 False : successful execution.
2698 2699 True : an error occurred.
2699 2700 """
2700 2701
2701 2702 # Set our own excepthook in case the user code tries to call it
2702 2703 # directly, so that the IPython crash handler doesn't get triggered
2703 2704 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2704 2705
2705 2706 # we save the original sys.excepthook in the instance, in case config
2706 2707 # code (such as magics) needs access to it.
2707 2708 self.sys_excepthook = old_excepthook
2708 2709 outflag = 1 # happens in more places, so it's easier as default
2709 2710 try:
2710 2711 try:
2711 2712 self.hooks.pre_run_code_hook()
2712 2713 #rprint('Running code', repr(code_obj)) # dbg
2713 2714 exec code_obj in self.user_global_ns, self.user_ns
2714 2715 finally:
2715 2716 # Reset our crash handler in place
2716 2717 sys.excepthook = old_excepthook
2717 2718 except SystemExit:
2718 2719 self.showtraceback(exception_only=True)
2719 2720 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2720 2721 except self.custom_exceptions:
2721 2722 etype,value,tb = sys.exc_info()
2722 2723 self.CustomTB(etype,value,tb)
2723 2724 except:
2724 2725 self.showtraceback()
2725 2726 else:
2726 2727 outflag = 0
2727 2728 return outflag
2728 2729
2729 2730 # For backwards compatibility
2730 2731 runcode = run_code
2731 2732
2732 2733 #-------------------------------------------------------------------------
2733 2734 # Things related to GUI support and pylab
2734 2735 #-------------------------------------------------------------------------
2735 2736
2736 2737 def enable_gui(self, gui=None):
2737 2738 raise NotImplementedError('Implement enable_gui in a subclass')
2738 2739
2739 2740 def enable_pylab(self, gui=None, import_all=True):
2740 2741 """Activate pylab support at runtime.
2741 2742
2742 2743 This turns on support for matplotlib, preloads into the interactive
2743 2744 namespace all of numpy and pylab, and configures IPython to correctly
2744 2745 interact with the GUI event loop. The GUI backend to be used can be
2745 2746 optionally selected with the optional :param:`gui` argument.
2746 2747
2747 2748 Parameters
2748 2749 ----------
2749 2750 gui : optional, string
2750 2751
2751 2752 If given, dictates the choice of matplotlib GUI backend to use
2752 2753 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2753 2754 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2754 2755 matplotlib (as dictated by the matplotlib build-time options plus the
2755 2756 user's matplotlibrc configuration file). Note that not all backends
2756 2757 make sense in all contexts, for example a terminal ipython can't
2757 2758 display figures inline.
2758 2759 """
2759 2760 from IPython.core.pylabtools import mpl_runner
2760 2761 # We want to prevent the loading of pylab to pollute the user's
2761 2762 # namespace as shown by the %who* magics, so we execute the activation
2762 2763 # code in an empty namespace, and we update *both* user_ns and
2763 2764 # user_ns_hidden with this information.
2764 2765 ns = {}
2765 2766 try:
2766 2767 gui = pylab_activate(ns, gui, import_all, self)
2767 2768 except KeyError:
2768 2769 error("Backend %r not supported" % gui)
2769 2770 return
2770 2771 self.user_ns.update(ns)
2771 2772 self.user_ns_hidden.update(ns)
2772 2773 # Now we must activate the gui pylab wants to use, and fix %run to take
2773 2774 # plot updates into account
2774 2775 self.enable_gui(gui)
2775 2776 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2776 2777 mpl_runner(self.safe_execfile)
2777 2778
2778 2779 #-------------------------------------------------------------------------
2779 2780 # Utilities
2780 2781 #-------------------------------------------------------------------------
2781 2782
2782 2783 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
2783 2784 """Expand python variables in a string.
2784 2785
2785 2786 The depth argument indicates how many frames above the caller should
2786 2787 be walked to look for the local namespace where to expand variables.
2787 2788
2788 2789 The global namespace for expansion is always the user's interactive
2789 2790 namespace.
2790 2791 """
2791 2792 ns = self.user_ns.copy()
2792 2793 ns.update(sys._getframe(depth+1).f_locals)
2793 2794 ns.pop('self', None)
2794 2795 try:
2795 2796 cmd = formatter.format(cmd, **ns)
2796 2797 except Exception:
2797 2798 # if formatter couldn't format, just let it go untransformed
2798 2799 pass
2799 2800 return cmd
2800 2801
2801 2802 def mktempfile(self, data=None, prefix='ipython_edit_'):
2802 2803 """Make a new tempfile and return its filename.
2803 2804
2804 2805 This makes a call to tempfile.mktemp, but it registers the created
2805 2806 filename internally so ipython cleans it up at exit time.
2806 2807
2807 2808 Optional inputs:
2808 2809
2809 2810 - data(None): if data is given, it gets written out to the temp file
2810 2811 immediately, and the file is closed again."""
2811 2812
2812 2813 filename = tempfile.mktemp('.py', prefix)
2813 2814 self.tempfiles.append(filename)
2814 2815
2815 2816 if data:
2816 2817 tmp_file = open(filename,'w')
2817 2818 tmp_file.write(data)
2818 2819 tmp_file.close()
2819 2820 return filename
2820 2821
2821 2822 # TODO: This should be removed when Term is refactored.
2822 2823 def write(self,data):
2823 2824 """Write a string to the default output"""
2824 2825 io.stdout.write(data)
2825 2826
2826 2827 # TODO: This should be removed when Term is refactored.
2827 2828 def write_err(self,data):
2828 2829 """Write a string to the default error output"""
2829 2830 io.stderr.write(data)
2830 2831
2831 2832 def ask_yes_no(self, prompt, default=None):
2832 2833 if self.quiet:
2833 2834 return True
2834 2835 return ask_yes_no(prompt,default)
2835 2836
2836 2837 def show_usage(self):
2837 2838 """Show a usage message"""
2838 2839 page.page(IPython.core.usage.interactive_usage)
2839 2840
2840 2841 def extract_input_lines(self, range_str, raw=False):
2841 2842 """Return as a string a set of input history slices.
2842 2843
2843 2844 Parameters
2844 2845 ----------
2845 2846 range_str : string
2846 2847 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
2847 2848 since this function is for use by magic functions which get their
2848 2849 arguments as strings. The number before the / is the session
2849 2850 number: ~n goes n back from the current session.
2850 2851
2851 2852 Optional Parameters:
2852 2853 - raw(False): by default, the processed input is used. If this is
2853 2854 true, the raw input history is used instead.
2854 2855
2855 2856 Note that slices can be called with two notations:
2856 2857
2857 2858 N:M -> standard python form, means including items N...(M-1).
2858 2859
2859 2860 N-M -> include items N..M (closed endpoint)."""
2860 2861 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
2861 2862 return "\n".join(x for _, _, x in lines)
2862 2863
2863 2864 def find_user_code(self, target, raw=True, py_only=False):
2864 2865 """Get a code string from history, file, url, or a string or macro.
2865 2866
2866 2867 This is mainly used by magic functions.
2867 2868
2868 2869 Parameters
2869 2870 ----------
2870 2871
2871 2872 target : str
2872 2873
2873 2874 A string specifying code to retrieve. This will be tried respectively
2874 2875 as: ranges of input history (see %history for syntax), url,
2875 2876 correspnding .py file, filename, or an expression evaluating to a
2876 2877 string or Macro in the user namespace.
2877 2878
2878 2879 raw : bool
2879 2880 If true (default), retrieve raw history. Has no effect on the other
2880 2881 retrieval mechanisms.
2881 2882
2882 2883 py_only : bool (default False)
2883 2884 Only try to fetch python code, do not try alternative methods to decode file
2884 2885 if unicode fails.
2885 2886
2886 2887 Returns
2887 2888 -------
2888 2889 A string of code.
2889 2890
2890 2891 ValueError is raised if nothing is found, and TypeError if it evaluates
2891 2892 to an object of another type. In each case, .args[0] is a printable
2892 2893 message.
2893 2894 """
2894 2895 code = self.extract_input_lines(target, raw=raw) # Grab history
2895 2896 if code:
2896 2897 return code
2897 2898 utarget = unquote_filename(target)
2898 2899 try:
2899 2900 if utarget.startswith(('http://', 'https://')):
2900 2901 return openpy.read_py_url(utarget, skip_encoding_cookie=True)
2901 2902 except UnicodeDecodeError:
2902 2903 if not py_only :
2903 2904 response = urllib.urlopen(target)
2904 2905 return response.read().decode('latin1')
2905 2906 raise ValueError(("'%s' seem to be unreadable.") % utarget)
2906 2907
2907 2908 potential_target = [target]
2908 2909 try :
2909 2910 potential_target.insert(0,get_py_filename(target))
2910 2911 except IOError:
2911 2912 pass
2912 2913
2913 2914 for tgt in potential_target :
2914 2915 if os.path.isfile(tgt): # Read file
2915 2916 try :
2916 2917 return openpy.read_py_file(tgt, skip_encoding_cookie=True)
2917 2918 except UnicodeDecodeError :
2918 2919 if not py_only :
2919 2920 with io_open(tgt,'r', encoding='latin1') as f :
2920 2921 return f.read()
2921 2922 raise ValueError(("'%s' seem to be unreadable.") % target)
2922 2923
2923 2924 try: # User namespace
2924 2925 codeobj = eval(target, self.user_ns)
2925 2926 except Exception:
2926 2927 raise ValueError(("'%s' was not found in history, as a file, url, "
2927 2928 "nor in the user namespace.") % target)
2928 2929 if isinstance(codeobj, basestring):
2929 2930 return codeobj
2930 2931 elif isinstance(codeobj, Macro):
2931 2932 return codeobj.value
2932 2933
2933 2934 raise TypeError("%s is neither a string nor a macro." % target,
2934 2935 codeobj)
2935 2936
2936 2937 #-------------------------------------------------------------------------
2937 2938 # Things related to IPython exiting
2938 2939 #-------------------------------------------------------------------------
2939 2940 def atexit_operations(self):
2940 2941 """This will be executed at the time of exit.
2941 2942
2942 2943 Cleanup operations and saving of persistent data that is done
2943 2944 unconditionally by IPython should be performed here.
2944 2945
2945 2946 For things that may depend on startup flags or platform specifics (such
2946 2947 as having readline or not), register a separate atexit function in the
2947 2948 code that has the appropriate information, rather than trying to
2948 2949 clutter
2949 2950 """
2950 2951 # Close the history session (this stores the end time and line count)
2951 2952 # this must be *before* the tempfile cleanup, in case of temporary
2952 2953 # history db
2953 2954 self.history_manager.end_session()
2954 2955
2955 2956 # Cleanup all tempfiles left around
2956 2957 for tfile in self.tempfiles:
2957 2958 try:
2958 2959 os.unlink(tfile)
2959 2960 except OSError:
2960 2961 pass
2961 2962
2962 2963 # Clear all user namespaces to release all references cleanly.
2963 2964 self.reset(new_session=False)
2964 2965
2965 2966 # Run user hooks
2966 2967 self.hooks.shutdown_hook()
2967 2968
2968 2969 def cleanup(self):
2969 2970 self.restore_sys_module_state()
2970 2971
2971 2972
2972 2973 class InteractiveShellABC(object):
2973 2974 """An abstract base class for InteractiveShell."""
2974 2975 __metaclass__ = abc.ABCMeta
2975 2976
2976 2977 InteractiveShellABC.register(InteractiveShell)
@@ -1,40 +1,41 b''
1 1 """Implementation of all the magic functions built into IPython.
2 2 """
3 3 #-----------------------------------------------------------------------------
4 4 # Copyright (c) 2012 The IPython Development Team.
5 5 #
6 6 # Distributed under the terms of the Modified BSD License.
7 7 #
8 8 # The full license is in the file COPYING.txt, distributed with this software.
9 9 #-----------------------------------------------------------------------------
10 10
11 11 #-----------------------------------------------------------------------------
12 12 # Imports
13 13 #-----------------------------------------------------------------------------
14 14
15 15 from ..magic import Magics, magics_class
16 16 from .auto import AutoMagics
17 17 from .basic import BasicMagics
18 18 from .code import CodeMagics, MacroToEdit
19 19 from .config import ConfigMagics
20 20 from .deprecated import DeprecatedMagics
21 21 from .execution import ExecutionMagics
22 22 from .extension import ExtensionMagics
23 23 from .history import HistoryMagics
24 24 from .logging import LoggingMagics
25 25 from .namespace import NamespaceMagics
26 26 from .osm import OSMagics
27 27 from .pylab import PylabMagics
28 from .script import ScriptMagics
28 29
29 30 #-----------------------------------------------------------------------------
30 31 # Magic implementation classes
31 32 #-----------------------------------------------------------------------------
32 33
33 34 @magics_class
34 35 class UserMagics(Magics):
35 36 """Placeholder for user-defined magics to be added at runtime.
36 37
37 38 All magics are eventually merged into a single namespace at runtime, but we
38 39 use this class to isolate the magics defined dynamically by the user into
39 40 their own class.
40 41 """
General Comments 0
You need to be logged in to leave comments. Login now