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