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