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