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