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