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