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