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