##// END OF EJS Templates
Merge pull request #9471 from takluyver/dont-update-prompt-width...
Matthias Bussonnier -
r22435:d031b96f merge
parent child Browse files
Show More
@@ -0,0 +1,73 b''
1 """Terminal input and output prompts."""
2 from __future__ import print_function
3
4 from pygments.token import Token
5 import sys
6
7 from IPython.core.displayhook import DisplayHook
8
9 class Prompts(object):
10 def __init__(self, shell):
11 self.shell = shell
12
13 def in_prompt_tokens(self, cli=None):
14 return [
15 (Token.Prompt, 'In ['),
16 (Token.PromptNum, str(self.shell.execution_count)),
17 (Token.Prompt, ']: '),
18 ]
19
20 def _width(self):
21 in_tokens = self.in_prompt_tokens()
22 return sum(len(s) for (t, s) in in_tokens)
23
24 def continuation_prompt_tokens(self, cli=None, width=None):
25 if width is None:
26 width = self._width()
27 return [
28 (Token.Prompt, (' ' * (width - 5)) + '...: '),
29 ]
30
31 def rewrite_prompt_tokens(self):
32 width = self._width()
33 return [
34 (Token.Prompt, ('-' * (width - 2)) + '> '),
35 ]
36
37 def out_prompt_tokens(self):
38 return [
39 (Token.OutPrompt, 'Out['),
40 (Token.OutPromptNum, str(self.shell.execution_count)),
41 (Token.OutPrompt, ']: '),
42 ]
43
44 class ClassicPrompts(Prompts):
45 def in_prompt_tokens(self, cli=None):
46 return [
47 (Token.Prompt, '>>> '),
48 ]
49
50 def continuation_prompt_tokens(self, cli=None, width=None):
51 return [
52 (Token.Prompt, '... ')
53 ]
54
55 def rewrite_prompt_tokens(self):
56 return []
57
58 def out_prompt_tokens(self):
59 return []
60
61 class RichPromptDisplayHook(DisplayHook):
62 """Subclass of base display hook using coloured prompt"""
63 def write_output_prompt(self):
64 sys.stdout.write(self.shell.separate_out)
65 self.prompt_end_newline = False
66 if self.do_full_cache:
67 tokens = self.shell.prompts.out_prompt_tokens()
68 if tokens and tokens[-1][1].endswith('\n'):
69 self.prompt_end_newline = True
70 if self.shell.pt_cli:
71 self.shell.pt_cli.print_tokens(tokens)
72 else:
73 print(*(s for t, s in tokens), sep='')
@@ -0,0 +1,26 b''
1 """This is an example that shows how to create new prompts for IPython
2 """
3
4 from IPython.terminal.prompts import Prompts, Token
5 import os
6
7 class MyPrompt(Prompts):
8
9 def in_prompt_tokens(self, cli=None):
10 return [(Token, os.getcwd()),
11 (Token.Prompt, '>>>')]
12
13 def load_ipython_extension(shell):
14 new_prompts = MyPrompt(shell)
15 new_prompts.old_prompts = shell.prompts
16 shell.prompts = new_prompts
17
18 def unload_ipython_extension(shell):
19 if not hasattr(shell.prompts, 'old_prompts'):
20 print("cannot unload")
21 else:
22 shell.prompts = shell.prompts.old_prompts
23
24
25
26
@@ -1,293 +1,295 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Displayhook for IPython.
3 3
4 4 This defines a callable class that IPython uses for `sys.displayhook`.
5 5 """
6 6
7 7 # Copyright (c) IPython Development Team.
8 8 # Distributed under the terms of the Modified BSD License.
9 9
10 10 from __future__ import print_function
11 11
12 12 import sys
13 13 import io as _io
14 14 import tokenize
15 15
16 16 from traitlets.config.configurable import Configurable
17 17 from IPython.utils.py3compat import builtin_mod, cast_unicode_py2
18 18 from traitlets import Instance, Float
19 19 from warnings import warn
20 20
21 21 # TODO: Move the various attributes (cache_size, [others now moved]). Some
22 22 # of these are also attributes of InteractiveShell. They should be on ONE object
23 23 # only and the other objects should ask that one object for their values.
24 24
25 25 class DisplayHook(Configurable):
26 26 """The custom IPython displayhook to replace sys.displayhook.
27 27
28 28 This class does many things, but the basic idea is that it is a callable
29 29 that gets called anytime user code returns a value.
30 30 """
31 31
32 32 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
33 33 allow_none=True)
34 34 exec_result = Instance('IPython.core.interactiveshell.ExecutionResult',
35 35 allow_none=True)
36 36 cull_fraction = Float(0.2)
37 37
38 38 def __init__(self, shell=None, cache_size=1000, **kwargs):
39 39 super(DisplayHook, self).__init__(shell=shell, **kwargs)
40 40 cache_size_min = 3
41 41 if cache_size <= 0:
42 42 self.do_full_cache = 0
43 43 cache_size = 0
44 44 elif cache_size < cache_size_min:
45 45 self.do_full_cache = 0
46 46 cache_size = 0
47 47 warn('caching was disabled (min value for cache size is %s).' %
48 48 cache_size_min,level=3)
49 49 else:
50 50 self.do_full_cache = 1
51 51
52 52 self.cache_size = cache_size
53 53
54 54 # we need a reference to the user-level namespace
55 55 self.shell = shell
56 56
57 57 self._,self.__,self.___ = '','',''
58 58
59 59 # these are deliberately global:
60 60 to_user_ns = {'_':self._,'__':self.__,'___':self.___}
61 61 self.shell.user_ns.update(to_user_ns)
62 62
63 63 @property
64 64 def prompt_count(self):
65 65 return self.shell.execution_count
66 66
67 67 #-------------------------------------------------------------------------
68 68 # Methods used in __call__. Override these methods to modify the behavior
69 69 # of the displayhook.
70 70 #-------------------------------------------------------------------------
71 71
72 72 def check_for_underscore(self):
73 73 """Check if the user has set the '_' variable by hand."""
74 74 # If something injected a '_' variable in __builtin__, delete
75 75 # ipython's automatic one so we don't clobber that. gettext() in
76 76 # particular uses _, so we need to stay away from it.
77 77 if '_' in builtin_mod.__dict__:
78 78 try:
79 79 del self.shell.user_ns['_']
80 80 except KeyError:
81 81 pass
82 82
83 83 def quiet(self):
84 84 """Should we silence the display hook because of ';'?"""
85 85 # do not print output if input ends in ';'
86 86
87 87 try:
88 88 cell = cast_unicode_py2(self.shell.history_manager.input_hist_parsed[-1])
89 89 except IndexError:
90 90 # some uses of ipshellembed may fail here
91 91 return False
92 92
93 93 sio = _io.StringIO(cell)
94 94 tokens = list(tokenize.generate_tokens(sio.readline))
95 95
96 96 for token in reversed(tokens):
97 97 if token[0] in (tokenize.ENDMARKER, tokenize.NL, tokenize.NEWLINE, tokenize.COMMENT):
98 98 continue
99 99 if (token[0] == tokenize.OP) and (token[1] == ';'):
100 100 return True
101 101 else:
102 102 return False
103 103
104 104 def start_displayhook(self):
105 105 """Start the displayhook, initializing resources."""
106 106 pass
107 107
108 108 def write_output_prompt(self):
109 109 """Write the output prompt.
110 110
111 111 The default implementation simply writes the prompt to
112 112 ``io.stdout``.
113 113 """
114 114 # Use write, not print which adds an extra space.
115 115 sys.stdout.write(self.shell.separate_out)
116 outprompt = self.shell.prompt_manager.render('out')
116 outprompt = 'Out[{}]: '.format(self.shell.execution_count)
117 117 if self.do_full_cache:
118 118 sys.stdout.write(outprompt)
119 119
120 120 def compute_format_data(self, result):
121 121 """Compute format data of the object to be displayed.
122 122
123 123 The format data is a generalization of the :func:`repr` of an object.
124 124 In the default implementation the format data is a :class:`dict` of
125 125 key value pair where the keys are valid MIME types and the values
126 126 are JSON'able data structure containing the raw data for that MIME
127 127 type. It is up to frontends to determine pick a MIME to to use and
128 128 display that data in an appropriate manner.
129 129
130 130 This method only computes the format data for the object and should
131 131 NOT actually print or write that to a stream.
132 132
133 133 Parameters
134 134 ----------
135 135 result : object
136 136 The Python object passed to the display hook, whose format will be
137 137 computed.
138 138
139 139 Returns
140 140 -------
141 141 (format_dict, md_dict) : dict
142 142 format_dict is a :class:`dict` whose keys are valid MIME types and values are
143 143 JSON'able raw data for that MIME type. It is recommended that
144 144 all return values of this should always include the "text/plain"
145 145 MIME type representation of the object.
146 146 md_dict is a :class:`dict` with the same MIME type keys
147 147 of metadata associated with each output.
148 148
149 149 """
150 150 return self.shell.display_formatter.format(result)
151 151
152 # This can be set to True by the write_output_prompt method in a subclass
153 prompt_end_newline = False
154
152 155 def write_format_data(self, format_dict, md_dict=None):
153 156 """Write the format data dict to the frontend.
154 157
155 158 This default version of this method simply writes the plain text
156 159 representation of the object to ``io.stdout``. Subclasses should
157 160 override this method to send the entire `format_dict` to the
158 161 frontends.
159 162
160 163 Parameters
161 164 ----------
162 165 format_dict : dict
163 166 The format dict for the object passed to `sys.displayhook`.
164 167 md_dict : dict (optional)
165 168 The metadata dict to be associated with the display data.
166 169 """
167 170 if 'text/plain' not in format_dict:
168 171 # nothing to do
169 172 return
170 173 # We want to print because we want to always make sure we have a
171 174 # newline, even if all the prompt separators are ''. This is the
172 175 # standard IPython behavior.
173 176 result_repr = format_dict['text/plain']
174 177 if '\n' in result_repr:
175 178 # So that multi-line strings line up with the left column of
176 179 # the screen, instead of having the output prompt mess up
177 180 # their first line.
178 181 # We use the prompt template instead of the expanded prompt
179 182 # because the expansion may add ANSI escapes that will interfere
180 183 # with our ability to determine whether or not we should add
181 184 # a newline.
182 prompt_template = self.shell.prompt_manager.out_template
183 if prompt_template and not prompt_template.endswith('\n'):
185 if not self.prompt_end_newline:
184 186 # But avoid extraneous empty lines.
185 187 result_repr = '\n' + result_repr
186 188
187 189 print(result_repr)
188 190
189 191 def update_user_ns(self, result):
190 192 """Update user_ns with various things like _, __, _1, etc."""
191 193
192 194 # Avoid recursive reference when displaying _oh/Out
193 195 if result is not self.shell.user_ns['_oh']:
194 196 if len(self.shell.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
195 197 self.cull_cache()
196 198 # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
197 199 # we cause buggy behavior for things like gettext).
198 200
199 201 if '_' not in builtin_mod.__dict__:
200 202 self.___ = self.__
201 203 self.__ = self._
202 204 self._ = result
203 205 self.shell.push({'_':self._,
204 206 '__':self.__,
205 207 '___':self.___}, interactive=False)
206 208
207 209 # hackish access to top-level namespace to create _1,_2... dynamically
208 210 to_main = {}
209 211 if self.do_full_cache:
210 212 new_result = '_'+repr(self.prompt_count)
211 213 to_main[new_result] = result
212 214 self.shell.push(to_main, interactive=False)
213 215 self.shell.user_ns['_oh'][self.prompt_count] = result
214 216
215 217 def fill_exec_result(self, result):
216 218 if self.exec_result is not None:
217 219 self.exec_result.result = result
218 220
219 221 def log_output(self, format_dict):
220 222 """Log the output."""
221 223 if 'text/plain' not in format_dict:
222 224 # nothing to do
223 225 return
224 226 if self.shell.logger.log_output:
225 227 self.shell.logger.log_write(format_dict['text/plain'], 'output')
226 228 self.shell.history_manager.output_hist_reprs[self.prompt_count] = \
227 229 format_dict['text/plain']
228 230
229 231 def finish_displayhook(self):
230 232 """Finish up all displayhook activities."""
231 233 sys.stdout.write(self.shell.separate_out2)
232 234 sys.stdout.flush()
233 235
234 236 def __call__(self, result=None):
235 237 """Printing with history cache management.
236 238
237 239 This is invoked everytime the interpreter needs to print, and is
238 240 activated by setting the variable sys.displayhook to it.
239 241 """
240 242 self.check_for_underscore()
241 243 if result is not None and not self.quiet():
242 244 self.start_displayhook()
243 245 self.write_output_prompt()
244 246 format_dict, md_dict = self.compute_format_data(result)
245 247 self.update_user_ns(result)
246 248 self.fill_exec_result(result)
247 249 if format_dict:
248 250 self.write_format_data(format_dict, md_dict)
249 251 self.log_output(format_dict)
250 252 self.finish_displayhook()
251 253
252 254 def cull_cache(self):
253 255 """Output cache is full, cull the oldest entries"""
254 256 oh = self.shell.user_ns.get('_oh', {})
255 257 sz = len(oh)
256 258 cull_count = max(int(sz * self.cull_fraction), 2)
257 259 warn('Output cache limit (currently {sz} entries) hit.\n'
258 260 'Flushing oldest {cull_count} entries.'.format(sz=sz, cull_count=cull_count))
259 261
260 262 for i, n in enumerate(sorted(oh)):
261 263 if i >= cull_count:
262 264 break
263 265 self.shell.user_ns.pop('_%i' % n, None)
264 266 oh.pop(n, None)
265 267
266 268
267 269 def flush(self):
268 270 if not self.do_full_cache:
269 271 raise ValueError("You shouldn't have reached the cache flush "
270 272 "if full caching is not enabled!")
271 273 # delete auto-generated vars from global namespace
272 274
273 275 for n in range(1,self.prompt_count + 1):
274 276 key = '_'+repr(n)
275 277 try:
276 278 del self.shell.user_ns[key]
277 279 except: pass
278 280 # In some embedded circumstances, the user_ns doesn't have the
279 281 # '_oh' key set up.
280 282 oh = self.shell.user_ns.get('_oh', None)
281 283 if oh is not None:
282 284 oh.clear()
283 285
284 286 # Release our own references to objects:
285 287 self._, self.__, self.___ = '', '', ''
286 288
287 289 if '_' not in builtin_mod.__dict__:
288 290 self.shell.user_ns.update({'_':None,'__':None, '___':None})
289 291 import gc
290 292 # TODO: Is this really needed?
291 293 # IronPython blocks here forever
292 294 if sys.platform != "cli":
293 295 gc.collect()
@@ -1,3239 +1,3234 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 from __future__ import absolute_import, print_function
14 14
15 15 import __future__
16 16 import abc
17 17 import ast
18 18 import atexit
19 19 import functools
20 20 import os
21 21 import re
22 22 import runpy
23 23 import sys
24 24 import tempfile
25 25 import traceback
26 26 import types
27 27 import subprocess
28 28 import warnings
29 29 from io import open as io_open
30 30
31 31 from pickleshare import PickleShareDB
32 32
33 33 from traitlets.config.configurable import SingletonConfigurable
34 34 from IPython.core import oinspect
35 35 from IPython.core import magic
36 36 from IPython.core import page
37 37 from IPython.core import prefilter
38 38 from IPython.core import shadowns
39 39 from IPython.core import ultratb
40 40 from IPython.core.alias import Alias, AliasManager
41 41 from IPython.core.autocall import ExitAutocall
42 42 from IPython.core.builtin_trap import BuiltinTrap
43 43 from IPython.core.events import EventManager, available_events
44 44 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
45 45 from IPython.core.debugger import Pdb
46 46 from IPython.core.display_trap import DisplayTrap
47 47 from IPython.core.displayhook import DisplayHook
48 48 from IPython.core.displaypub import DisplayPublisher
49 49 from IPython.core.error import InputRejected, UsageError
50 50 from IPython.core.extensions import ExtensionManager
51 51 from IPython.core.formatters import DisplayFormatter
52 52 from IPython.core.history import HistoryManager
53 53 from IPython.core.inputsplitter import ESC_MAGIC, ESC_MAGIC2
54 54 from IPython.core.logger import Logger
55 55 from IPython.core.macro import Macro
56 56 from IPython.core.payload import PayloadManager
57 57 from IPython.core.prefilter import PrefilterManager
58 58 from IPython.core.profiledir import ProfileDir
59 from IPython.core.prompts import PromptManager
60 59 from IPython.core.usage import default_banner
61 60 from IPython.testing.skipdoctest import skip_doctest_py2, skip_doctest
62 61 from IPython.utils import PyColorize
63 62 from IPython.utils import io
64 63 from IPython.utils import py3compat
65 64 from IPython.utils import openpy
66 65 from IPython.utils.contexts import NoOpContext
67 66 from IPython.utils.decorators import undoc
68 67 from IPython.utils.io import ask_yes_no
69 68 from IPython.utils.ipstruct import Struct
70 69 from IPython.paths import get_ipython_dir
71 70 from IPython.utils.path import get_home_dir, get_py_filename, unquote_filename, ensure_dir_exists
72 71 from IPython.utils.process import system, getoutput
73 72 from IPython.utils.py3compat import (builtin_mod, unicode_type, string_types,
74 73 with_metaclass, iteritems)
75 74 from IPython.utils.strdispatch import StrDispatch
76 75 from IPython.utils.syspathcontext import prepended_to_syspath
77 76 from IPython.utils.text import (format_screen, LSString, SList,
78 77 DollarFormatter)
79 78 from traitlets import (
80 79 Integer, Bool, CaselessStrEnum, Enum, List, Dict, Unicode, Instance, Type,
81 80 observe, default,
82 81 )
83 82 from warnings import warn
84 83 from logging import error
85 84 import IPython.core.hooks
86 85
87 86 #-----------------------------------------------------------------------------
88 87 # Globals
89 88 #-----------------------------------------------------------------------------
90 89
91 90 # compiled regexps for autoindent management
92 91 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
93 92
94 93 #-----------------------------------------------------------------------------
95 94 # Utilities
96 95 #-----------------------------------------------------------------------------
97 96
98 97 @undoc
99 98 def softspace(file, newvalue):
100 99 """Copied from code.py, to remove the dependency"""
101 100
102 101 oldvalue = 0
103 102 try:
104 103 oldvalue = file.softspace
105 104 except AttributeError:
106 105 pass
107 106 try:
108 107 file.softspace = newvalue
109 108 except (AttributeError, TypeError):
110 109 # "attribute-less object" or "read-only attributes"
111 110 pass
112 111 return oldvalue
113 112
114 113 @undoc
115 114 def no_op(*a, **kw): pass
116 115
117 116
118 117 class SpaceInInput(Exception): pass
119 118
120 119
121 120 def get_default_colors():
122 121 if sys.platform=='darwin':
123 122 return "LightBG"
124 123 elif os.name=='nt':
125 124 return 'Linux'
126 125 else:
127 126 return 'Linux'
128 127
129 128
130 129 class SeparateUnicode(Unicode):
131 130 r"""A Unicode subclass to validate separate_in, separate_out, etc.
132 131
133 132 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
134 133 """
135 134
136 135 def validate(self, obj, value):
137 136 if value == '0': value = ''
138 137 value = value.replace('\\n','\n')
139 138 return super(SeparateUnicode, self).validate(obj, value)
140 139
141 140
142 141 @undoc
143 142 class DummyMod(object):
144 143 """A dummy module used for IPython's interactive module when
145 144 a namespace must be assigned to the module's __dict__."""
146 145 pass
147 146
148 147
149 148 class ExecutionResult(object):
150 149 """The result of a call to :meth:`InteractiveShell.run_cell`
151 150
152 151 Stores information about what took place.
153 152 """
154 153 execution_count = None
155 154 error_before_exec = None
156 155 error_in_exec = None
157 156 result = None
158 157
159 158 @property
160 159 def success(self):
161 160 return (self.error_before_exec is None) and (self.error_in_exec is None)
162 161
163 162 def raise_error(self):
164 163 """Reraises error if `success` is `False`, otherwise does nothing"""
165 164 if self.error_before_exec is not None:
166 165 raise self.error_before_exec
167 166 if self.error_in_exec is not None:
168 167 raise self.error_in_exec
169 168
170 169
171 170 class InteractiveShell(SingletonConfigurable):
172 171 """An enhanced, interactive shell for Python."""
173 172
174 173 _instance = None
175 174
176 175 ast_transformers = List([], help=
177 176 """
178 177 A list of ast.NodeTransformer subclass instances, which will be applied
179 178 to user input before code is run.
180 179 """
181 180 ).tag(config=True)
182 181
183 182 autocall = Enum((0,1,2), default_value=0, help=
184 183 """
185 184 Make IPython automatically call any callable object even if you didn't
186 185 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
187 186 automatically. The value can be '0' to disable the feature, '1' for
188 187 'smart' autocall, where it is not applied if there are no more
189 188 arguments on the line, and '2' for 'full' autocall, where all callable
190 189 objects are automatically called (even if no arguments are present).
191 190 """
192 191 ).tag(config=True)
193 192 # TODO: remove all autoindent logic and put into frontends.
194 193 # We can't do this yet because even runlines uses the autoindent.
195 194 autoindent = Bool(True, help=
196 195 """
197 196 Autoindent IPython code entered interactively.
198 197 """
199 198 ).tag(config=True)
200 199 automagic = Bool(True, help=
201 200 """
202 201 Enable magic commands to be called without the leading %.
203 202 """
204 203 ).tag(config=True)
205 204
206 205 banner1 = Unicode(default_banner,
207 206 help="""The part of the banner to be printed before the profile"""
208 207 ).tag(config=True)
209 208 banner2 = Unicode('',
210 209 help="""The part of the banner to be printed after the profile"""
211 210 ).tag(config=True)
212 211
213 212 cache_size = Integer(1000, help=
214 213 """
215 214 Set the size of the output cache. The default is 1000, you can
216 215 change it permanently in your config file. Setting it to 0 completely
217 216 disables the caching system, and the minimum value accepted is 20 (if
218 217 you provide a value less than 20, it is reset to 0 and a warning is
219 218 issued). This limit is defined because otherwise you'll spend more
220 219 time re-flushing a too small cache than working
221 220 """
222 221 ).tag(config=True)
223 222 color_info = Bool(True, help=
224 223 """
225 224 Use colors for displaying information about objects. Because this
226 225 information is passed through a pager (like 'less'), and some pagers
227 226 get confused with color codes, this capability can be turned off.
228 227 """
229 228 ).tag(config=True)
230 229 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
231 230 default_value=get_default_colors(),
232 231 help="Set the color scheme (NoColor, Linux, or LightBG)."
233 232 ).tag(config=True)
234 233 colors_force = Bool(False, help=
235 234 """
236 235 Force use of ANSI color codes, regardless of OS and readline
237 236 availability.
238 237 """
239 238 # FIXME: This is essentially a hack to allow ZMQShell to show colors
240 239 # without readline on Win32. When the ZMQ formatting system is
241 240 # refactored, this should be removed.
242 241 )
243 242 debug = Bool(False).tag(config=True)
244 243 deep_reload = Bool(False, help=
245 244 """
246 245 **Deprecated**
247 246
248 247 Will be removed in IPython 6.0
249 248
250 249 Enable deep (recursive) reloading by default. IPython can use the
251 250 deep_reload module which reloads changes in modules recursively (it
252 251 replaces the reload() function, so you don't need to change anything to
253 252 use it). `deep_reload` forces a full reload of modules whose code may
254 253 have changed, which the default reload() function does not. When
255 254 deep_reload is off, IPython will use the normal reload(), but
256 255 deep_reload will still be available as dreload().
257 256 """
258 257 ).tag(config=True)
259 258 disable_failing_post_execute = Bool(False,
260 259 help="Don't call post-execute functions that have failed in the past."
261 260 ).tag(config=True)
262 261 display_formatter = Instance(DisplayFormatter, allow_none=True)
263 262 displayhook_class = Type(DisplayHook)
264 263 display_pub_class = Type(DisplayPublisher)
265 264 data_pub_class = None
266 265
267 266 exit_now = Bool(False)
268 267 exiter = Instance(ExitAutocall)
269 268 @default('exiter')
270 269 def _exiter_default(self):
271 270 return ExitAutocall(self)
272 271 # Monotonically increasing execution counter
273 272 execution_count = Integer(1)
274 273 filename = Unicode("<ipython console>")
275 274 ipython_dir= Unicode('').tag(config=True) # Set to get_ipython_dir() in __init__
276 275
277 276 # Input splitter, to transform input line by line and detect when a block
278 277 # is ready to be executed.
279 278 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
280 279 (), {'line_input_checker': True})
281 280
282 281 # This InputSplitter instance is used to transform completed cells before
283 282 # running them. It allows cell magics to contain blank lines.
284 283 input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
285 284 (), {'line_input_checker': False})
286 285
287 286 logstart = Bool(False, help=
288 287 """
289 288 Start logging to the default log file in overwrite mode.
290 289 Use `logappend` to specify a log file to **append** logs to.
291 290 """
292 291 ).tag(config=True)
293 292 logfile = Unicode('', help=
294 293 """
295 294 The name of the logfile to use.
296 295 """
297 296 ).tag(config=True)
298 297 logappend = Unicode('', help=
299 298 """
300 299 Start logging to the given file in append mode.
301 300 Use `logfile` to specify a log file to **overwrite** logs to.
302 301 """
303 302 ).tag(config=True)
304 303 object_info_string_level = Enum((0,1,2), default_value=0,
305 304 ).tag(config=True)
306 305 pdb = Bool(False, help=
307 306 """
308 307 Automatically call the pdb debugger after every exception.
309 308 """
310 309 ).tag(config=True)
311 310 multiline_history = Bool(sys.platform != 'win32',
312 311 help="Save multi-line entries as one entry in readline history"
313 312 ).tag(config=True)
314 313 display_page = Bool(False,
315 314 help="""If True, anything that would be passed to the pager
316 315 will be displayed as regular output instead."""
317 316 ).tag(config=True)
318 317
319 318 # deprecated prompt traits:
320 319
321 320 prompt_in1 = Unicode('In [\\#]: ',
322 321 help="Deprecated, will be removed in IPython 5.0, use PromptManager.in_template"
323 322 ).tag(config=True)
324 323 prompt_in2 = Unicode(' .\\D.: ',
325 324 help="Deprecated, will be removed in IPython 5.0, use PromptManager.in2_template"
326 325 ).tag(config=True)
327 326 prompt_out = Unicode('Out[\\#]: ',
328 327 help="Deprecated, will be removed in IPython 5.0, use PromptManager.out_template"
329 328 ).tag(config=True)
330 329 prompts_pad_left = Bool(True,
331 330 help="Deprecated, will be removed in IPython 5.0, use PromptManager.justify"
332 331 ).tag(config=True)
333 332
334 333 @observe('prompt_in1', 'prompt_in2', 'prompt_out', 'prompt_pad_left')
335 334 def _prompt_trait_changed(self, change):
336 335 table = {
337 336 'prompt_in1' : 'in_template',
338 337 'prompt_in2' : 'in2_template',
339 338 'prompt_out' : 'out_template',
340 339 'prompts_pad_left' : 'justify',
341 340 }
342 341 name = change['name']
343 342 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(
344 343 name=name, newname=table[name])
345 344 )
346 345 # protect against weird cases where self.config may not exist:
347 346 if self.config is not None:
348 347 # propagate to corresponding PromptManager trait
349 348 setattr(self.config.PromptManager, table[name], change['new'])
350 349
351 350 show_rewritten_input = Bool(True,
352 351 help="Show rewritten input, e.g. for autocall."
353 352 ).tag(config=True)
354 353
355 354 quiet = Bool(False).tag(config=True)
356 355
357 356 history_length = Integer(10000,
358 357 help='Total length of command history'
359 358 ).tag(config=True)
360 359
361 360 history_load_length = Integer(1000, help=
362 361 """
363 362 The number of saved history entries to be loaded
364 363 into the readline buffer at startup.
365 364 """
366 365 ).tag(config=True)
367 366
368 367 # The readline stuff will eventually be moved to the terminal subclass
369 368 # but for now, we can't do that as readline is welded in everywhere.
370 369 readline_use = Bool(True).tag(config=True)
371 370 readline_remove_delims = Unicode('-/~').tag(config=True)
372 371 readline_delims = Unicode() # set by init_readline()
373 372 # don't use \M- bindings by default, because they
374 373 # conflict with 8-bit encodings. See gh-58,gh-88
375 374 readline_parse_and_bind = List([
376 375 'tab: complete',
377 376 '"\C-l": clear-screen',
378 377 'set show-all-if-ambiguous on',
379 378 '"\C-o": tab-insert',
380 379 '"\C-r": reverse-search-history',
381 380 '"\C-s": forward-search-history',
382 381 '"\C-p": history-search-backward',
383 382 '"\C-n": history-search-forward',
384 383 '"\e[A": history-search-backward',
385 384 '"\e[B": history-search-forward',
386 385 '"\C-k": kill-line',
387 386 '"\C-u": unix-line-discard',
388 387 ]).tag(config=True)
389 388
390 389 _custom_readline_config = False
391 390
392 391 @observe('readline_parse_and_bind')
393 392 def _readline_parse_and_bind_changed(self, change):
394 393 # notice that readline config is customized
395 394 # indicates that it should have higher priority than inputrc
396 395 self._custom_readline_config = True
397 396
398 397 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
399 398 default_value='last_expr',
400 399 help="""
401 400 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
402 401 run interactively (displaying output from expressions)."""
403 402 ).tag(config=True)
404 403
405 404 # TODO: this part of prompt management should be moved to the frontends.
406 405 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
407 406 separate_in = SeparateUnicode('\n').tag(config=True)
408 407 separate_out = SeparateUnicode('').tag(config=True)
409 408 separate_out2 = SeparateUnicode('').tag(config=True)
410 409 wildcards_case_sensitive = Bool(True).tag(config=True)
411 410 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
412 411 default_value='Context').tag(config=True)
413 412
414 413 # Subcomponents of InteractiveShell
415 414 alias_manager = Instance('IPython.core.alias.AliasManager', allow_none=True)
416 415 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)
417 416 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap', allow_none=True)
418 417 display_trap = Instance('IPython.core.display_trap.DisplayTrap', allow_none=True)
419 418 extension_manager = Instance('IPython.core.extensions.ExtensionManager', allow_none=True)
420 419 payload_manager = Instance('IPython.core.payload.PayloadManager', allow_none=True)
421 420 history_manager = Instance('IPython.core.history.HistoryAccessorBase', allow_none=True)
422 421 magics_manager = Instance('IPython.core.magic.MagicsManager', allow_none=True)
423 422
424 423 profile_dir = Instance('IPython.core.application.ProfileDir', allow_none=True)
425 424 @property
426 425 def profile(self):
427 426 if self.profile_dir is not None:
428 427 name = os.path.basename(self.profile_dir.location)
429 428 return name.replace('profile_','')
430 429
431 430
432 431 # Private interface
433 432 _post_execute = Dict()
434 433
435 434 # Tracks any GUI loop loaded for pylab
436 435 pylab_gui_select = None
437 436
438 437 def __init__(self, ipython_dir=None, profile_dir=None,
439 438 user_module=None, user_ns=None,
440 439 custom_exceptions=((), None), **kwargs):
441 440
442 441 # This is where traits with a config_key argument are updated
443 442 # from the values on config.
444 443 super(InteractiveShell, self).__init__(**kwargs)
445 444 self.configurables = [self]
446 445
447 446 # These are relatively independent and stateless
448 447 self.init_ipython_dir(ipython_dir)
449 448 self.init_profile_dir(profile_dir)
450 449 self.init_instance_attrs()
451 450 self.init_environment()
452 451
453 452 # Check if we're in a virtualenv, and set up sys.path.
454 453 self.init_virtualenv()
455 454
456 455 # Create namespaces (user_ns, user_global_ns, etc.)
457 456 self.init_create_namespaces(user_module, user_ns)
458 457 # This has to be done after init_create_namespaces because it uses
459 458 # something in self.user_ns, but before init_sys_modules, which
460 459 # is the first thing to modify sys.
461 460 # TODO: When we override sys.stdout and sys.stderr before this class
462 461 # is created, we are saving the overridden ones here. Not sure if this
463 462 # is what we want to do.
464 463 self.save_sys_module_state()
465 464 self.init_sys_modules()
466 465
467 466 # While we're trying to have each part of the code directly access what
468 467 # it needs without keeping redundant references to objects, we have too
469 468 # much legacy code that expects ip.db to exist.
470 469 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
471 470
472 471 self.init_history()
473 472 self.init_encoding()
474 473 self.init_prefilter()
475 474
476 475 self.init_syntax_highlighting()
477 476 self.init_hooks()
478 477 self.init_events()
479 478 self.init_pushd_popd_magic()
480 479 # self.init_traceback_handlers use to be here, but we moved it below
481 480 # because it and init_io have to come after init_readline.
482 481 self.init_user_ns()
483 482 self.init_logger()
484 483 self.init_builtins()
485 484
486 485 # The following was in post_config_initialization
487 486 self.init_inspector()
488 487 # init_readline() must come before init_io(), because init_io uses
489 488 # readline related things.
490 489 self.init_readline()
491 490 # We save this here in case user code replaces raw_input, but it needs
492 491 # to be after init_readline(), because PyPy's readline works by replacing
493 492 # raw_input.
494 493 if py3compat.PY3:
495 494 self.raw_input_original = input
496 495 else:
497 496 self.raw_input_original = raw_input
498 497 # init_completer must come after init_readline, because it needs to
499 498 # know whether readline is present or not system-wide to configure the
500 499 # completers, since the completion machinery can now operate
501 500 # independently of readline (e.g. over the network)
502 501 self.init_completer()
503 502 # TODO: init_io() needs to happen before init_traceback handlers
504 503 # because the traceback handlers hardcode the stdout/stderr streams.
505 504 # This logic in in debugger.Pdb and should eventually be changed.
506 505 self.init_io()
507 506 self.init_traceback_handlers(custom_exceptions)
508 507 self.init_prompts()
509 508 self.init_display_formatter()
510 509 self.init_display_pub()
511 510 self.init_data_pub()
512 511 self.init_displayhook()
513 512 self.init_magics()
514 513 self.init_alias()
515 514 self.init_logstart()
516 515 self.init_pdb()
517 516 self.init_extension_manager()
518 517 self.init_payload()
519 518 self.init_deprecation_warnings()
520 519 self.hooks.late_startup_hook()
521 520 self.events.trigger('shell_initialized', self)
522 521 atexit.register(self.atexit_operations)
523 522
524 523 def get_ipython(self):
525 524 """Return the currently running IPython instance."""
526 525 return self
527 526
528 527 #-------------------------------------------------------------------------
529 528 # Trait changed handlers
530 529 #-------------------------------------------------------------------------
531 530 @observe('ipython_dir')
532 531 def _ipython_dir_changed(self, change):
533 532 ensure_dir_exists(change['new'])
534 533
535 534 def set_autoindent(self,value=None):
536 535 """Set the autoindent flag.
537 536
538 537 If called with no arguments, it acts as a toggle."""
539 538 if value is None:
540 539 self.autoindent = not self.autoindent
541 540 else:
542 541 self.autoindent = value
543 542
544 543 #-------------------------------------------------------------------------
545 544 # init_* methods called by __init__
546 545 #-------------------------------------------------------------------------
547 546
548 547 def init_ipython_dir(self, ipython_dir):
549 548 if ipython_dir is not None:
550 549 self.ipython_dir = ipython_dir
551 550 return
552 551
553 552 self.ipython_dir = get_ipython_dir()
554 553
555 554 def init_profile_dir(self, profile_dir):
556 555 if profile_dir is not None:
557 556 self.profile_dir = profile_dir
558 557 return
559 558 self.profile_dir =\
560 559 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
561 560
562 561 def init_instance_attrs(self):
563 562 self.more = False
564 563
565 564 # command compiler
566 565 self.compile = CachingCompiler()
567 566
568 567 # Make an empty namespace, which extension writers can rely on both
569 568 # existing and NEVER being used by ipython itself. This gives them a
570 569 # convenient location for storing additional information and state
571 570 # their extensions may require, without fear of collisions with other
572 571 # ipython names that may develop later.
573 572 self.meta = Struct()
574 573
575 574 # Temporary files used for various purposes. Deleted at exit.
576 575 self.tempfiles = []
577 576 self.tempdirs = []
578 577
579 578 # Keep track of readline usage (later set by init_readline)
580 579 self.has_readline = False
581 580
582 581 # keep track of where we started running (mainly for crash post-mortem)
583 582 # This is not being used anywhere currently.
584 583 self.starting_dir = py3compat.getcwd()
585 584
586 585 # Indentation management
587 586 self.indent_current_nsp = 0
588 587
589 588 # Dict to track post-execution functions that have been registered
590 589 self._post_execute = {}
591 590
592 591 def init_environment(self):
593 592 """Any changes we need to make to the user's environment."""
594 593 pass
595 594
596 595 def init_encoding(self):
597 596 # Get system encoding at startup time. Certain terminals (like Emacs
598 597 # under Win32 have it set to None, and we need to have a known valid
599 598 # encoding to use in the raw_input() method
600 599 try:
601 600 self.stdin_encoding = sys.stdin.encoding or 'ascii'
602 601 except AttributeError:
603 602 self.stdin_encoding = 'ascii'
604 603
605 604 def init_syntax_highlighting(self):
606 605 # Python source parser/formatter for syntax highlighting
607 606 pyformat = PyColorize.Parser().format
608 607 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
609 608
610 609 def init_pushd_popd_magic(self):
611 610 # for pushd/popd management
612 611 self.home_dir = get_home_dir()
613 612
614 613 self.dir_stack = []
615 614
616 615 def init_logger(self):
617 616 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
618 617 logmode='rotate')
619 618
620 619 def init_logstart(self):
621 620 """Initialize logging in case it was requested at the command line.
622 621 """
623 622 if self.logappend:
624 623 self.magic('logstart %s append' % self.logappend)
625 624 elif self.logfile:
626 625 self.magic('logstart %s' % self.logfile)
627 626 elif self.logstart:
628 627 self.magic('logstart')
629 628
630 629 def init_deprecation_warnings(self):
631 630 """
632 631 register default filter for deprecation warning.
633 632
634 633 This will allow deprecation warning of function used interactively to show
635 634 warning to users, and still hide deprecation warning from libraries import.
636 635 """
637 636 warnings.filterwarnings("default", category=DeprecationWarning, module=self.user_ns.get("__name__"))
638 637
639 638 def init_builtins(self):
640 639 # A single, static flag that we set to True. Its presence indicates
641 640 # that an IPython shell has been created, and we make no attempts at
642 641 # removing on exit or representing the existence of more than one
643 642 # IPython at a time.
644 643 builtin_mod.__dict__['__IPYTHON__'] = True
645 644
646 645 self.builtin_trap = BuiltinTrap(shell=self)
647 646
648 647 def init_inspector(self):
649 648 # Object inspector
650 649 self.inspector = oinspect.Inspector(oinspect.InspectColors,
651 650 PyColorize.ANSICodeColors,
652 651 'NoColor',
653 652 self.object_info_string_level)
654 653
655 654 def init_io(self):
656 655 # This will just use sys.stdout and sys.stderr. If you want to
657 656 # override sys.stdout and sys.stderr themselves, you need to do that
658 657 # *before* instantiating this class, because io holds onto
659 658 # references to the underlying streams.
660 659 if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:
661 660 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
662 661 else:
663 662 io.stdout = io.IOStream(sys.stdout)
664 663 io.stderr = io.IOStream(sys.stderr)
665 664
666 665 def init_prompts(self):
667 self.prompt_manager = PromptManager(shell=self, parent=self)
668 self.configurables.append(self.prompt_manager)
669 666 # Set system prompts, so that scripts can decide if they are running
670 667 # interactively.
671 668 sys.ps1 = 'In : '
672 669 sys.ps2 = '...: '
673 670 sys.ps3 = 'Out: '
674 671
675 672 def init_display_formatter(self):
676 673 self.display_formatter = DisplayFormatter(parent=self)
677 674 self.configurables.append(self.display_formatter)
678 675
679 676 def init_display_pub(self):
680 677 self.display_pub = self.display_pub_class(parent=self)
681 678 self.configurables.append(self.display_pub)
682 679
683 680 def init_data_pub(self):
684 681 if not self.data_pub_class:
685 682 self.data_pub = None
686 683 return
687 684 self.data_pub = self.data_pub_class(parent=self)
688 685 self.configurables.append(self.data_pub)
689 686
690 687 def init_displayhook(self):
691 688 # Initialize displayhook, set in/out prompts and printing system
692 689 self.displayhook = self.displayhook_class(
693 690 parent=self,
694 691 shell=self,
695 692 cache_size=self.cache_size,
696 693 )
697 694 self.configurables.append(self.displayhook)
698 695 # This is a context manager that installs/revmoes the displayhook at
699 696 # the appropriate time.
700 697 self.display_trap = DisplayTrap(hook=self.displayhook)
701 698
702 699 def init_virtualenv(self):
703 700 """Add a virtualenv to sys.path so the user can import modules from it.
704 701 This isn't perfect: it doesn't use the Python interpreter with which the
705 702 virtualenv was built, and it ignores the --no-site-packages option. A
706 703 warning will appear suggesting the user installs IPython in the
707 704 virtualenv, but for many cases, it probably works well enough.
708 705
709 706 Adapted from code snippets online.
710 707
711 708 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
712 709 """
713 710 if 'VIRTUAL_ENV' not in os.environ:
714 711 # Not in a virtualenv
715 712 return
716 713
717 714 # venv detection:
718 715 # stdlib venv may symlink sys.executable, so we can't use realpath.
719 716 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
720 717 # So we just check every item in the symlink tree (generally <= 3)
721 718 p = os.path.normcase(sys.executable)
722 719 paths = [p]
723 720 while os.path.islink(p):
724 721 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
725 722 paths.append(p)
726 723 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
727 724 if any(p.startswith(p_venv) for p in paths):
728 725 # Running properly in the virtualenv, don't need to do anything
729 726 return
730 727
731 728 warn("Attempting to work in a virtualenv. If you encounter problems, please "
732 729 "install IPython inside the virtualenv.")
733 730 if sys.platform == "win32":
734 731 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
735 732 else:
736 733 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
737 734 'python%d.%d' % sys.version_info[:2], 'site-packages')
738 735
739 736 import site
740 737 sys.path.insert(0, virtual_env)
741 738 site.addsitedir(virtual_env)
742 739
743 740 #-------------------------------------------------------------------------
744 741 # Things related to injections into the sys module
745 742 #-------------------------------------------------------------------------
746 743
747 744 def save_sys_module_state(self):
748 745 """Save the state of hooks in the sys module.
749 746
750 747 This has to be called after self.user_module is created.
751 748 """
752 749 self._orig_sys_module_state = {'stdin': sys.stdin,
753 750 'stdout': sys.stdout,
754 751 'stderr': sys.stderr,
755 752 'excepthook': sys.excepthook}
756 753 self._orig_sys_modules_main_name = self.user_module.__name__
757 754 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
758 755
759 756 def restore_sys_module_state(self):
760 757 """Restore the state of the sys module."""
761 758 try:
762 759 for k, v in iteritems(self._orig_sys_module_state):
763 760 setattr(sys, k, v)
764 761 except AttributeError:
765 762 pass
766 763 # Reset what what done in self.init_sys_modules
767 764 if self._orig_sys_modules_main_mod is not None:
768 765 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
769 766
770 767 #-------------------------------------------------------------------------
771 768 # Things related to the banner
772 769 #-------------------------------------------------------------------------
773 770
774 771 @property
775 772 def banner(self):
776 773 banner = self.banner1
777 774 if self.profile and self.profile != 'default':
778 775 banner += '\nIPython profile: %s\n' % self.profile
779 776 if self.banner2:
780 777 banner += '\n' + self.banner2
781 778 return banner
782 779
783 780 def show_banner(self, banner=None):
784 781 if banner is None:
785 782 banner = self.banner
786 783 sys.stdout.write(banner)
787 784
788 785 #-------------------------------------------------------------------------
789 786 # Things related to hooks
790 787 #-------------------------------------------------------------------------
791 788
792 789 def init_hooks(self):
793 790 # hooks holds pointers used for user-side customizations
794 791 self.hooks = Struct()
795 792
796 793 self.strdispatchers = {}
797 794
798 795 # Set all default hooks, defined in the IPython.hooks module.
799 796 hooks = IPython.core.hooks
800 797 for hook_name in hooks.__all__:
801 798 # default hooks have priority 100, i.e. low; user hooks should have
802 799 # 0-100 priority
803 800 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
804 801
805 802 if self.display_page:
806 803 self.set_hook('show_in_pager', page.as_hook(page.display_page), 90)
807 804
808 805 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
809 806 _warn_deprecated=True):
810 807 """set_hook(name,hook) -> sets an internal IPython hook.
811 808
812 809 IPython exposes some of its internal API as user-modifiable hooks. By
813 810 adding your function to one of these hooks, you can modify IPython's
814 811 behavior to call at runtime your own routines."""
815 812
816 813 # At some point in the future, this should validate the hook before it
817 814 # accepts it. Probably at least check that the hook takes the number
818 815 # of args it's supposed to.
819 816
820 817 f = types.MethodType(hook,self)
821 818
822 819 # check if the hook is for strdispatcher first
823 820 if str_key is not None:
824 821 sdp = self.strdispatchers.get(name, StrDispatch())
825 822 sdp.add_s(str_key, f, priority )
826 823 self.strdispatchers[name] = sdp
827 824 return
828 825 if re_key is not None:
829 826 sdp = self.strdispatchers.get(name, StrDispatch())
830 827 sdp.add_re(re.compile(re_key), f, priority )
831 828 self.strdispatchers[name] = sdp
832 829 return
833 830
834 831 dp = getattr(self.hooks, name, None)
835 832 if name not in IPython.core.hooks.__all__:
836 833 print("Warning! Hook '%s' is not one of %s" % \
837 834 (name, IPython.core.hooks.__all__ ))
838 835
839 836 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
840 837 alternative = IPython.core.hooks.deprecated[name]
841 838 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative))
842 839
843 840 if not dp:
844 841 dp = IPython.core.hooks.CommandChainDispatcher()
845 842
846 843 try:
847 844 dp.add(f,priority)
848 845 except AttributeError:
849 846 # it was not commandchain, plain old func - replace
850 847 dp = f
851 848
852 849 setattr(self.hooks,name, dp)
853 850
854 851 #-------------------------------------------------------------------------
855 852 # Things related to events
856 853 #-------------------------------------------------------------------------
857 854
858 855 def init_events(self):
859 856 self.events = EventManager(self, available_events)
860 857
861 858 self.events.register("pre_execute", self._clear_warning_registry)
862 859
863 860 def register_post_execute(self, func):
864 861 """DEPRECATED: Use ip.events.register('post_run_cell', func)
865 862
866 863 Register a function for calling after code execution.
867 864 """
868 865 warn("ip.register_post_execute is deprecated, use "
869 866 "ip.events.register('post_run_cell', func) instead.")
870 867 self.events.register('post_run_cell', func)
871 868
872 869 def _clear_warning_registry(self):
873 870 # clear the warning registry, so that different code blocks with
874 871 # overlapping line number ranges don't cause spurious suppression of
875 872 # warnings (see gh-6611 for details)
876 873 if "__warningregistry__" in self.user_global_ns:
877 874 del self.user_global_ns["__warningregistry__"]
878 875
879 876 #-------------------------------------------------------------------------
880 877 # Things related to the "main" module
881 878 #-------------------------------------------------------------------------
882 879
883 880 def new_main_mod(self, filename, modname):
884 881 """Return a new 'main' module object for user code execution.
885 882
886 883 ``filename`` should be the path of the script which will be run in the
887 884 module. Requests with the same filename will get the same module, with
888 885 its namespace cleared.
889 886
890 887 ``modname`` should be the module name - normally either '__main__' or
891 888 the basename of the file without the extension.
892 889
893 890 When scripts are executed via %run, we must keep a reference to their
894 891 __main__ module around so that Python doesn't
895 892 clear it, rendering references to module globals useless.
896 893
897 894 This method keeps said reference in a private dict, keyed by the
898 895 absolute path of the script. This way, for multiple executions of the
899 896 same script we only keep one copy of the namespace (the last one),
900 897 thus preventing memory leaks from old references while allowing the
901 898 objects from the last execution to be accessible.
902 899 """
903 900 filename = os.path.abspath(filename)
904 901 try:
905 902 main_mod = self._main_mod_cache[filename]
906 903 except KeyError:
907 904 main_mod = self._main_mod_cache[filename] = types.ModuleType(
908 905 py3compat.cast_bytes_py2(modname),
909 906 doc="Module created for script run in IPython")
910 907 else:
911 908 main_mod.__dict__.clear()
912 909 main_mod.__name__ = modname
913 910
914 911 main_mod.__file__ = filename
915 912 # It seems pydoc (and perhaps others) needs any module instance to
916 913 # implement a __nonzero__ method
917 914 main_mod.__nonzero__ = lambda : True
918 915
919 916 return main_mod
920 917
921 918 def clear_main_mod_cache(self):
922 919 """Clear the cache of main modules.
923 920
924 921 Mainly for use by utilities like %reset.
925 922
926 923 Examples
927 924 --------
928 925
929 926 In [15]: import IPython
930 927
931 928 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
932 929
933 930 In [17]: len(_ip._main_mod_cache) > 0
934 931 Out[17]: True
935 932
936 933 In [18]: _ip.clear_main_mod_cache()
937 934
938 935 In [19]: len(_ip._main_mod_cache) == 0
939 936 Out[19]: True
940 937 """
941 938 self._main_mod_cache.clear()
942 939
943 940 #-------------------------------------------------------------------------
944 941 # Things related to debugging
945 942 #-------------------------------------------------------------------------
946 943
947 944 def init_pdb(self):
948 945 # Set calling of pdb on exceptions
949 946 # self.call_pdb is a property
950 947 self.call_pdb = self.pdb
951 948
952 949 def _get_call_pdb(self):
953 950 return self._call_pdb
954 951
955 952 def _set_call_pdb(self,val):
956 953
957 954 if val not in (0,1,False,True):
958 955 raise ValueError('new call_pdb value must be boolean')
959 956
960 957 # store value in instance
961 958 self._call_pdb = val
962 959
963 960 # notify the actual exception handlers
964 961 self.InteractiveTB.call_pdb = val
965 962
966 963 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
967 964 'Control auto-activation of pdb at exceptions')
968 965
969 966 def debugger(self,force=False):
970 967 """Call the pdb debugger.
971 968
972 969 Keywords:
973 970
974 971 - force(False): by default, this routine checks the instance call_pdb
975 972 flag and does not actually invoke the debugger if the flag is false.
976 973 The 'force' option forces the debugger to activate even if the flag
977 974 is false.
978 975 """
979 976
980 977 if not (force or self.call_pdb):
981 978 return
982 979
983 980 if not hasattr(sys,'last_traceback'):
984 981 error('No traceback has been produced, nothing to debug.')
985 982 return
986 983
987 984
988 985 with self.readline_no_record:
989 986 self.InteractiveTB.debugger(force=True)
990 987
991 988 #-------------------------------------------------------------------------
992 989 # Things related to IPython's various namespaces
993 990 #-------------------------------------------------------------------------
994 991 default_user_namespaces = True
995 992
996 993 def init_create_namespaces(self, user_module=None, user_ns=None):
997 994 # Create the namespace where the user will operate. user_ns is
998 995 # normally the only one used, and it is passed to the exec calls as
999 996 # the locals argument. But we do carry a user_global_ns namespace
1000 997 # given as the exec 'globals' argument, This is useful in embedding
1001 998 # situations where the ipython shell opens in a context where the
1002 999 # distinction between locals and globals is meaningful. For
1003 1000 # non-embedded contexts, it is just the same object as the user_ns dict.
1004 1001
1005 1002 # FIXME. For some strange reason, __builtins__ is showing up at user
1006 1003 # level as a dict instead of a module. This is a manual fix, but I
1007 1004 # should really track down where the problem is coming from. Alex
1008 1005 # Schmolck reported this problem first.
1009 1006
1010 1007 # A useful post by Alex Martelli on this topic:
1011 1008 # Re: inconsistent value from __builtins__
1012 1009 # Von: Alex Martelli <aleaxit@yahoo.com>
1013 1010 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
1014 1011 # Gruppen: comp.lang.python
1015 1012
1016 1013 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
1017 1014 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
1018 1015 # > <type 'dict'>
1019 1016 # > >>> print type(__builtins__)
1020 1017 # > <type 'module'>
1021 1018 # > Is this difference in return value intentional?
1022 1019
1023 1020 # Well, it's documented that '__builtins__' can be either a dictionary
1024 1021 # or a module, and it's been that way for a long time. Whether it's
1025 1022 # intentional (or sensible), I don't know. In any case, the idea is
1026 1023 # that if you need to access the built-in namespace directly, you
1027 1024 # should start with "import __builtin__" (note, no 's') which will
1028 1025 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1029 1026
1030 1027 # These routines return a properly built module and dict as needed by
1031 1028 # the rest of the code, and can also be used by extension writers to
1032 1029 # generate properly initialized namespaces.
1033 1030 if (user_ns is not None) or (user_module is not None):
1034 1031 self.default_user_namespaces = False
1035 1032 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1036 1033
1037 1034 # A record of hidden variables we have added to the user namespace, so
1038 1035 # we can list later only variables defined in actual interactive use.
1039 1036 self.user_ns_hidden = {}
1040 1037
1041 1038 # Now that FakeModule produces a real module, we've run into a nasty
1042 1039 # problem: after script execution (via %run), the module where the user
1043 1040 # code ran is deleted. Now that this object is a true module (needed
1044 1041 # so doctest and other tools work correctly), the Python module
1045 1042 # teardown mechanism runs over it, and sets to None every variable
1046 1043 # present in that module. Top-level references to objects from the
1047 1044 # script survive, because the user_ns is updated with them. However,
1048 1045 # calling functions defined in the script that use other things from
1049 1046 # the script will fail, because the function's closure had references
1050 1047 # to the original objects, which are now all None. So we must protect
1051 1048 # these modules from deletion by keeping a cache.
1052 1049 #
1053 1050 # To avoid keeping stale modules around (we only need the one from the
1054 1051 # last run), we use a dict keyed with the full path to the script, so
1055 1052 # only the last version of the module is held in the cache. Note,
1056 1053 # however, that we must cache the module *namespace contents* (their
1057 1054 # __dict__). Because if we try to cache the actual modules, old ones
1058 1055 # (uncached) could be destroyed while still holding references (such as
1059 1056 # those held by GUI objects that tend to be long-lived)>
1060 1057 #
1061 1058 # The %reset command will flush this cache. See the cache_main_mod()
1062 1059 # and clear_main_mod_cache() methods for details on use.
1063 1060
1064 1061 # This is the cache used for 'main' namespaces
1065 1062 self._main_mod_cache = {}
1066 1063
1067 1064 # A table holding all the namespaces IPython deals with, so that
1068 1065 # introspection facilities can search easily.
1069 1066 self.ns_table = {'user_global':self.user_module.__dict__,
1070 1067 'user_local':self.user_ns,
1071 1068 'builtin':builtin_mod.__dict__
1072 1069 }
1073 1070
1074 1071 @property
1075 1072 def user_global_ns(self):
1076 1073 return self.user_module.__dict__
1077 1074
1078 1075 def prepare_user_module(self, user_module=None, user_ns=None):
1079 1076 """Prepare the module and namespace in which user code will be run.
1080 1077
1081 1078 When IPython is started normally, both parameters are None: a new module
1082 1079 is created automatically, and its __dict__ used as the namespace.
1083 1080
1084 1081 If only user_module is provided, its __dict__ is used as the namespace.
1085 1082 If only user_ns is provided, a dummy module is created, and user_ns
1086 1083 becomes the global namespace. If both are provided (as they may be
1087 1084 when embedding), user_ns is the local namespace, and user_module
1088 1085 provides the global namespace.
1089 1086
1090 1087 Parameters
1091 1088 ----------
1092 1089 user_module : module, optional
1093 1090 The current user module in which IPython is being run. If None,
1094 1091 a clean module will be created.
1095 1092 user_ns : dict, optional
1096 1093 A namespace in which to run interactive commands.
1097 1094
1098 1095 Returns
1099 1096 -------
1100 1097 A tuple of user_module and user_ns, each properly initialised.
1101 1098 """
1102 1099 if user_module is None and user_ns is not None:
1103 1100 user_ns.setdefault("__name__", "__main__")
1104 1101 user_module = DummyMod()
1105 1102 user_module.__dict__ = user_ns
1106 1103
1107 1104 if user_module is None:
1108 1105 user_module = types.ModuleType("__main__",
1109 1106 doc="Automatically created module for IPython interactive environment")
1110 1107
1111 1108 # We must ensure that __builtin__ (without the final 's') is always
1112 1109 # available and pointing to the __builtin__ *module*. For more details:
1113 1110 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1114 1111 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1115 1112 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1116 1113
1117 1114 if user_ns is None:
1118 1115 user_ns = user_module.__dict__
1119 1116
1120 1117 return user_module, user_ns
1121 1118
1122 1119 def init_sys_modules(self):
1123 1120 # We need to insert into sys.modules something that looks like a
1124 1121 # module but which accesses the IPython namespace, for shelve and
1125 1122 # pickle to work interactively. Normally they rely on getting
1126 1123 # everything out of __main__, but for embedding purposes each IPython
1127 1124 # instance has its own private namespace, so we can't go shoving
1128 1125 # everything into __main__.
1129 1126
1130 1127 # note, however, that we should only do this for non-embedded
1131 1128 # ipythons, which really mimic the __main__.__dict__ with their own
1132 1129 # namespace. Embedded instances, on the other hand, should not do
1133 1130 # this because they need to manage the user local/global namespaces
1134 1131 # only, but they live within a 'normal' __main__ (meaning, they
1135 1132 # shouldn't overtake the execution environment of the script they're
1136 1133 # embedded in).
1137 1134
1138 1135 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1139 1136 main_name = self.user_module.__name__
1140 1137 sys.modules[main_name] = self.user_module
1141 1138
1142 1139 def init_user_ns(self):
1143 1140 """Initialize all user-visible namespaces to their minimum defaults.
1144 1141
1145 1142 Certain history lists are also initialized here, as they effectively
1146 1143 act as user namespaces.
1147 1144
1148 1145 Notes
1149 1146 -----
1150 1147 All data structures here are only filled in, they are NOT reset by this
1151 1148 method. If they were not empty before, data will simply be added to
1152 1149 therm.
1153 1150 """
1154 1151 # This function works in two parts: first we put a few things in
1155 1152 # user_ns, and we sync that contents into user_ns_hidden so that these
1156 1153 # initial variables aren't shown by %who. After the sync, we add the
1157 1154 # rest of what we *do* want the user to see with %who even on a new
1158 1155 # session (probably nothing, so they really only see their own stuff)
1159 1156
1160 1157 # The user dict must *always* have a __builtin__ reference to the
1161 1158 # Python standard __builtin__ namespace, which must be imported.
1162 1159 # This is so that certain operations in prompt evaluation can be
1163 1160 # reliably executed with builtins. Note that we can NOT use
1164 1161 # __builtins__ (note the 's'), because that can either be a dict or a
1165 1162 # module, and can even mutate at runtime, depending on the context
1166 1163 # (Python makes no guarantees on it). In contrast, __builtin__ is
1167 1164 # always a module object, though it must be explicitly imported.
1168 1165
1169 1166 # For more details:
1170 1167 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1171 1168 ns = dict()
1172 1169
1173 1170 # make global variables for user access to the histories
1174 1171 ns['_ih'] = self.history_manager.input_hist_parsed
1175 1172 ns['_oh'] = self.history_manager.output_hist
1176 1173 ns['_dh'] = self.history_manager.dir_hist
1177 1174
1178 1175 ns['_sh'] = shadowns
1179 1176
1180 1177 # user aliases to input and output histories. These shouldn't show up
1181 1178 # in %who, as they can have very large reprs.
1182 1179 ns['In'] = self.history_manager.input_hist_parsed
1183 1180 ns['Out'] = self.history_manager.output_hist
1184 1181
1185 1182 # Store myself as the public api!!!
1186 1183 ns['get_ipython'] = self.get_ipython
1187 1184
1188 1185 ns['exit'] = self.exiter
1189 1186 ns['quit'] = self.exiter
1190 1187
1191 1188 # Sync what we've added so far to user_ns_hidden so these aren't seen
1192 1189 # by %who
1193 1190 self.user_ns_hidden.update(ns)
1194 1191
1195 1192 # Anything put into ns now would show up in %who. Think twice before
1196 1193 # putting anything here, as we really want %who to show the user their
1197 1194 # stuff, not our variables.
1198 1195
1199 1196 # Finally, update the real user's namespace
1200 1197 self.user_ns.update(ns)
1201 1198
1202 1199 @property
1203 1200 def all_ns_refs(self):
1204 1201 """Get a list of references to all the namespace dictionaries in which
1205 1202 IPython might store a user-created object.
1206 1203
1207 1204 Note that this does not include the displayhook, which also caches
1208 1205 objects from the output."""
1209 1206 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1210 1207 [m.__dict__ for m in self._main_mod_cache.values()]
1211 1208
1212 1209 def reset(self, new_session=True):
1213 1210 """Clear all internal namespaces, and attempt to release references to
1214 1211 user objects.
1215 1212
1216 1213 If new_session is True, a new history session will be opened.
1217 1214 """
1218 1215 # Clear histories
1219 1216 self.history_manager.reset(new_session)
1220 1217 # Reset counter used to index all histories
1221 1218 if new_session:
1222 1219 self.execution_count = 1
1223 1220
1224 1221 # Flush cached output items
1225 1222 if self.displayhook.do_full_cache:
1226 1223 self.displayhook.flush()
1227 1224
1228 1225 # The main execution namespaces must be cleared very carefully,
1229 1226 # skipping the deletion of the builtin-related keys, because doing so
1230 1227 # would cause errors in many object's __del__ methods.
1231 1228 if self.user_ns is not self.user_global_ns:
1232 1229 self.user_ns.clear()
1233 1230 ns = self.user_global_ns
1234 1231 drop_keys = set(ns.keys())
1235 1232 drop_keys.discard('__builtin__')
1236 1233 drop_keys.discard('__builtins__')
1237 1234 drop_keys.discard('__name__')
1238 1235 for k in drop_keys:
1239 1236 del ns[k]
1240 1237
1241 1238 self.user_ns_hidden.clear()
1242 1239
1243 1240 # Restore the user namespaces to minimal usability
1244 1241 self.init_user_ns()
1245 1242
1246 1243 # Restore the default and user aliases
1247 1244 self.alias_manager.clear_aliases()
1248 1245 self.alias_manager.init_aliases()
1249 1246
1250 1247 # Flush the private list of module references kept for script
1251 1248 # execution protection
1252 1249 self.clear_main_mod_cache()
1253 1250
1254 1251 def del_var(self, varname, by_name=False):
1255 1252 """Delete a variable from the various namespaces, so that, as
1256 1253 far as possible, we're not keeping any hidden references to it.
1257 1254
1258 1255 Parameters
1259 1256 ----------
1260 1257 varname : str
1261 1258 The name of the variable to delete.
1262 1259 by_name : bool
1263 1260 If True, delete variables with the given name in each
1264 1261 namespace. If False (default), find the variable in the user
1265 1262 namespace, and delete references to it.
1266 1263 """
1267 1264 if varname in ('__builtin__', '__builtins__'):
1268 1265 raise ValueError("Refusing to delete %s" % varname)
1269 1266
1270 1267 ns_refs = self.all_ns_refs
1271 1268
1272 1269 if by_name: # Delete by name
1273 1270 for ns in ns_refs:
1274 1271 try:
1275 1272 del ns[varname]
1276 1273 except KeyError:
1277 1274 pass
1278 1275 else: # Delete by object
1279 1276 try:
1280 1277 obj = self.user_ns[varname]
1281 1278 except KeyError:
1282 1279 raise NameError("name '%s' is not defined" % varname)
1283 1280 # Also check in output history
1284 1281 ns_refs.append(self.history_manager.output_hist)
1285 1282 for ns in ns_refs:
1286 1283 to_delete = [n for n, o in iteritems(ns) if o is obj]
1287 1284 for name in to_delete:
1288 1285 del ns[name]
1289 1286
1290 1287 # displayhook keeps extra references, but not in a dictionary
1291 1288 for name in ('_', '__', '___'):
1292 1289 if getattr(self.displayhook, name) is obj:
1293 1290 setattr(self.displayhook, name, None)
1294 1291
1295 1292 def reset_selective(self, regex=None):
1296 1293 """Clear selective variables from internal namespaces based on a
1297 1294 specified regular expression.
1298 1295
1299 1296 Parameters
1300 1297 ----------
1301 1298 regex : string or compiled pattern, optional
1302 1299 A regular expression pattern that will be used in searching
1303 1300 variable names in the users namespaces.
1304 1301 """
1305 1302 if regex is not None:
1306 1303 try:
1307 1304 m = re.compile(regex)
1308 1305 except TypeError:
1309 1306 raise TypeError('regex must be a string or compiled pattern')
1310 1307 # Search for keys in each namespace that match the given regex
1311 1308 # If a match is found, delete the key/value pair.
1312 1309 for ns in self.all_ns_refs:
1313 1310 for var in ns:
1314 1311 if m.search(var):
1315 1312 del ns[var]
1316 1313
1317 1314 def push(self, variables, interactive=True):
1318 1315 """Inject a group of variables into the IPython user namespace.
1319 1316
1320 1317 Parameters
1321 1318 ----------
1322 1319 variables : dict, str or list/tuple of str
1323 1320 The variables to inject into the user's namespace. If a dict, a
1324 1321 simple update is done. If a str, the string is assumed to have
1325 1322 variable names separated by spaces. A list/tuple of str can also
1326 1323 be used to give the variable names. If just the variable names are
1327 1324 give (list/tuple/str) then the variable values looked up in the
1328 1325 callers frame.
1329 1326 interactive : bool
1330 1327 If True (default), the variables will be listed with the ``who``
1331 1328 magic.
1332 1329 """
1333 1330 vdict = None
1334 1331
1335 1332 # We need a dict of name/value pairs to do namespace updates.
1336 1333 if isinstance(variables, dict):
1337 1334 vdict = variables
1338 1335 elif isinstance(variables, string_types+(list, tuple)):
1339 1336 if isinstance(variables, string_types):
1340 1337 vlist = variables.split()
1341 1338 else:
1342 1339 vlist = variables
1343 1340 vdict = {}
1344 1341 cf = sys._getframe(1)
1345 1342 for name in vlist:
1346 1343 try:
1347 1344 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1348 1345 except:
1349 1346 print('Could not get variable %s from %s' %
1350 1347 (name,cf.f_code.co_name))
1351 1348 else:
1352 1349 raise ValueError('variables must be a dict/str/list/tuple')
1353 1350
1354 1351 # Propagate variables to user namespace
1355 1352 self.user_ns.update(vdict)
1356 1353
1357 1354 # And configure interactive visibility
1358 1355 user_ns_hidden = self.user_ns_hidden
1359 1356 if interactive:
1360 1357 for name in vdict:
1361 1358 user_ns_hidden.pop(name, None)
1362 1359 else:
1363 1360 user_ns_hidden.update(vdict)
1364 1361
1365 1362 def drop_by_id(self, variables):
1366 1363 """Remove a dict of variables from the user namespace, if they are the
1367 1364 same as the values in the dictionary.
1368 1365
1369 1366 This is intended for use by extensions: variables that they've added can
1370 1367 be taken back out if they are unloaded, without removing any that the
1371 1368 user has overwritten.
1372 1369
1373 1370 Parameters
1374 1371 ----------
1375 1372 variables : dict
1376 1373 A dictionary mapping object names (as strings) to the objects.
1377 1374 """
1378 1375 for name, obj in iteritems(variables):
1379 1376 if name in self.user_ns and self.user_ns[name] is obj:
1380 1377 del self.user_ns[name]
1381 1378 self.user_ns_hidden.pop(name, None)
1382 1379
1383 1380 #-------------------------------------------------------------------------
1384 1381 # Things related to object introspection
1385 1382 #-------------------------------------------------------------------------
1386 1383
1387 1384 def _ofind(self, oname, namespaces=None):
1388 1385 """Find an object in the available namespaces.
1389 1386
1390 1387 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1391 1388
1392 1389 Has special code to detect magic functions.
1393 1390 """
1394 1391 oname = oname.strip()
1395 1392 #print '1- oname: <%r>' % oname # dbg
1396 1393 if not oname.startswith(ESC_MAGIC) and \
1397 1394 not oname.startswith(ESC_MAGIC2) and \
1398 1395 not py3compat.isidentifier(oname, dotted=True):
1399 1396 return dict(found=False)
1400 1397
1401 1398 if namespaces is None:
1402 1399 # Namespaces to search in:
1403 1400 # Put them in a list. The order is important so that we
1404 1401 # find things in the same order that Python finds them.
1405 1402 namespaces = [ ('Interactive', self.user_ns),
1406 1403 ('Interactive (global)', self.user_global_ns),
1407 1404 ('Python builtin', builtin_mod.__dict__),
1408 1405 ]
1409 1406
1410 1407 # initialize results to 'null'
1411 1408 found = False; obj = None; ospace = None;
1412 1409 ismagic = False; isalias = False; parent = None
1413 1410
1414 1411 # We need to special-case 'print', which as of python2.6 registers as a
1415 1412 # function but should only be treated as one if print_function was
1416 1413 # loaded with a future import. In this case, just bail.
1417 1414 if (oname == 'print' and not py3compat.PY3 and not \
1418 1415 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1419 1416 return {'found':found, 'obj':obj, 'namespace':ospace,
1420 1417 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1421 1418
1422 1419 # Look for the given name by splitting it in parts. If the head is
1423 1420 # found, then we look for all the remaining parts as members, and only
1424 1421 # declare success if we can find them all.
1425 1422 oname_parts = oname.split('.')
1426 1423 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1427 1424 for nsname,ns in namespaces:
1428 1425 try:
1429 1426 obj = ns[oname_head]
1430 1427 except KeyError:
1431 1428 continue
1432 1429 else:
1433 1430 #print 'oname_rest:', oname_rest # dbg
1434 1431 for idx, part in enumerate(oname_rest):
1435 1432 try:
1436 1433 parent = obj
1437 1434 # The last part is looked up in a special way to avoid
1438 1435 # descriptor invocation as it may raise or have side
1439 1436 # effects.
1440 1437 if idx == len(oname_rest) - 1:
1441 1438 obj = self._getattr_property(obj, part)
1442 1439 else:
1443 1440 obj = getattr(obj, part)
1444 1441 except:
1445 1442 # Blanket except b/c some badly implemented objects
1446 1443 # allow __getattr__ to raise exceptions other than
1447 1444 # AttributeError, which then crashes IPython.
1448 1445 break
1449 1446 else:
1450 1447 # If we finish the for loop (no break), we got all members
1451 1448 found = True
1452 1449 ospace = nsname
1453 1450 break # namespace loop
1454 1451
1455 1452 # Try to see if it's magic
1456 1453 if not found:
1457 1454 obj = None
1458 1455 if oname.startswith(ESC_MAGIC2):
1459 1456 oname = oname.lstrip(ESC_MAGIC2)
1460 1457 obj = self.find_cell_magic(oname)
1461 1458 elif oname.startswith(ESC_MAGIC):
1462 1459 oname = oname.lstrip(ESC_MAGIC)
1463 1460 obj = self.find_line_magic(oname)
1464 1461 else:
1465 1462 # search without prefix, so run? will find %run?
1466 1463 obj = self.find_line_magic(oname)
1467 1464 if obj is None:
1468 1465 obj = self.find_cell_magic(oname)
1469 1466 if obj is not None:
1470 1467 found = True
1471 1468 ospace = 'IPython internal'
1472 1469 ismagic = True
1473 1470 isalias = isinstance(obj, Alias)
1474 1471
1475 1472 # Last try: special-case some literals like '', [], {}, etc:
1476 1473 if not found and oname_head in ["''",'""','[]','{}','()']:
1477 1474 obj = eval(oname_head)
1478 1475 found = True
1479 1476 ospace = 'Interactive'
1480 1477
1481 1478 return {'found':found, 'obj':obj, 'namespace':ospace,
1482 1479 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1483 1480
1484 1481 @staticmethod
1485 1482 def _getattr_property(obj, attrname):
1486 1483 """Property-aware getattr to use in object finding.
1487 1484
1488 1485 If attrname represents a property, return it unevaluated (in case it has
1489 1486 side effects or raises an error.
1490 1487
1491 1488 """
1492 1489 if not isinstance(obj, type):
1493 1490 try:
1494 1491 # `getattr(type(obj), attrname)` is not guaranteed to return
1495 1492 # `obj`, but does so for property:
1496 1493 #
1497 1494 # property.__get__(self, None, cls) -> self
1498 1495 #
1499 1496 # The universal alternative is to traverse the mro manually
1500 1497 # searching for attrname in class dicts.
1501 1498 attr = getattr(type(obj), attrname)
1502 1499 except AttributeError:
1503 1500 pass
1504 1501 else:
1505 1502 # This relies on the fact that data descriptors (with both
1506 1503 # __get__ & __set__ magic methods) take precedence over
1507 1504 # instance-level attributes:
1508 1505 #
1509 1506 # class A(object):
1510 1507 # @property
1511 1508 # def foobar(self): return 123
1512 1509 # a = A()
1513 1510 # a.__dict__['foobar'] = 345
1514 1511 # a.foobar # == 123
1515 1512 #
1516 1513 # So, a property may be returned right away.
1517 1514 if isinstance(attr, property):
1518 1515 return attr
1519 1516
1520 1517 # Nothing helped, fall back.
1521 1518 return getattr(obj, attrname)
1522 1519
1523 1520 def _object_find(self, oname, namespaces=None):
1524 1521 """Find an object and return a struct with info about it."""
1525 1522 return Struct(self._ofind(oname, namespaces))
1526 1523
1527 1524 def _inspect(self, meth, oname, namespaces=None, **kw):
1528 1525 """Generic interface to the inspector system.
1529 1526
1530 1527 This function is meant to be called by pdef, pdoc & friends."""
1531 1528 info = self._object_find(oname, namespaces)
1532 1529 if info.found:
1533 1530 pmethod = getattr(self.inspector, meth)
1534 1531 formatter = format_screen if info.ismagic else None
1535 1532 if meth == 'pdoc':
1536 1533 pmethod(info.obj, oname, formatter)
1537 1534 elif meth == 'pinfo':
1538 1535 pmethod(info.obj, oname, formatter, info, **kw)
1539 1536 else:
1540 1537 pmethod(info.obj, oname)
1541 1538 else:
1542 1539 print('Object `%s` not found.' % oname)
1543 1540 return 'not found' # so callers can take other action
1544 1541
1545 1542 def object_inspect(self, oname, detail_level=0):
1546 1543 """Get object info about oname"""
1547 1544 with self.builtin_trap:
1548 1545 info = self._object_find(oname)
1549 1546 if info.found:
1550 1547 return self.inspector.info(info.obj, oname, info=info,
1551 1548 detail_level=detail_level
1552 1549 )
1553 1550 else:
1554 1551 return oinspect.object_info(name=oname, found=False)
1555 1552
1556 1553 def object_inspect_text(self, oname, detail_level=0):
1557 1554 """Get object info as formatted text"""
1558 1555 with self.builtin_trap:
1559 1556 info = self._object_find(oname)
1560 1557 if info.found:
1561 1558 return self.inspector._format_info(info.obj, oname, info=info,
1562 1559 detail_level=detail_level
1563 1560 )
1564 1561 else:
1565 1562 raise KeyError(oname)
1566 1563
1567 1564 #-------------------------------------------------------------------------
1568 1565 # Things related to history management
1569 1566 #-------------------------------------------------------------------------
1570 1567
1571 1568 def init_history(self):
1572 1569 """Sets up the command history, and starts regular autosaves."""
1573 1570 self.history_manager = HistoryManager(shell=self, parent=self)
1574 1571 self.configurables.append(self.history_manager)
1575 1572
1576 1573 #-------------------------------------------------------------------------
1577 1574 # Things related to exception handling and tracebacks (not debugging)
1578 1575 #-------------------------------------------------------------------------
1579 1576
1580 1577 debugger_cls = Pdb
1581 1578
1582 1579 def init_traceback_handlers(self, custom_exceptions):
1583 1580 # Syntax error handler.
1584 1581 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1585 1582
1586 1583 # The interactive one is initialized with an offset, meaning we always
1587 1584 # want to remove the topmost item in the traceback, which is our own
1588 1585 # internal code. Valid modes: ['Plain','Context','Verbose']
1589 1586 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1590 1587 color_scheme='NoColor',
1591 1588 tb_offset = 1,
1592 1589 check_cache=check_linecache_ipython,
1593 1590 debugger_cls=self.debugger_cls)
1594 1591
1595 1592 # The instance will store a pointer to the system-wide exception hook,
1596 1593 # so that runtime code (such as magics) can access it. This is because
1597 1594 # during the read-eval loop, it may get temporarily overwritten.
1598 1595 self.sys_excepthook = sys.excepthook
1599 1596
1600 1597 # and add any custom exception handlers the user may have specified
1601 1598 self.set_custom_exc(*custom_exceptions)
1602 1599
1603 1600 # Set the exception mode
1604 1601 self.InteractiveTB.set_mode(mode=self.xmode)
1605 1602
1606 1603 def set_custom_exc(self, exc_tuple, handler):
1607 1604 """set_custom_exc(exc_tuple, handler)
1608 1605
1609 1606 Set a custom exception handler, which will be called if any of the
1610 1607 exceptions in exc_tuple occur in the mainloop (specifically, in the
1611 1608 run_code() method).
1612 1609
1613 1610 Parameters
1614 1611 ----------
1615 1612
1616 1613 exc_tuple : tuple of exception classes
1617 1614 A *tuple* of exception classes, for which to call the defined
1618 1615 handler. It is very important that you use a tuple, and NOT A
1619 1616 LIST here, because of the way Python's except statement works. If
1620 1617 you only want to trap a single exception, use a singleton tuple::
1621 1618
1622 1619 exc_tuple == (MyCustomException,)
1623 1620
1624 1621 handler : callable
1625 1622 handler must have the following signature::
1626 1623
1627 1624 def my_handler(self, etype, value, tb, tb_offset=None):
1628 1625 ...
1629 1626 return structured_traceback
1630 1627
1631 1628 Your handler must return a structured traceback (a list of strings),
1632 1629 or None.
1633 1630
1634 1631 This will be made into an instance method (via types.MethodType)
1635 1632 of IPython itself, and it will be called if any of the exceptions
1636 1633 listed in the exc_tuple are caught. If the handler is None, an
1637 1634 internal basic one is used, which just prints basic info.
1638 1635
1639 1636 To protect IPython from crashes, if your handler ever raises an
1640 1637 exception or returns an invalid result, it will be immediately
1641 1638 disabled.
1642 1639
1643 1640 WARNING: by putting in your own exception handler into IPython's main
1644 1641 execution loop, you run a very good chance of nasty crashes. This
1645 1642 facility should only be used if you really know what you are doing."""
1646 1643
1647 1644 assert type(exc_tuple)==type(()) , \
1648 1645 "The custom exceptions must be given AS A TUPLE."
1649 1646
1650 1647 def dummy_handler(self, etype, value, tb, tb_offset=None):
1651 1648 print('*** Simple custom exception handler ***')
1652 1649 print('Exception type :',etype)
1653 1650 print('Exception value:',value)
1654 1651 print('Traceback :',tb)
1655 1652 #print 'Source code :','\n'.join(self.buffer)
1656 1653
1657 1654 def validate_stb(stb):
1658 1655 """validate structured traceback return type
1659 1656
1660 1657 return type of CustomTB *should* be a list of strings, but allow
1661 1658 single strings or None, which are harmless.
1662 1659
1663 1660 This function will *always* return a list of strings,
1664 1661 and will raise a TypeError if stb is inappropriate.
1665 1662 """
1666 1663 msg = "CustomTB must return list of strings, not %r" % stb
1667 1664 if stb is None:
1668 1665 return []
1669 1666 elif isinstance(stb, string_types):
1670 1667 return [stb]
1671 1668 elif not isinstance(stb, list):
1672 1669 raise TypeError(msg)
1673 1670 # it's a list
1674 1671 for line in stb:
1675 1672 # check every element
1676 1673 if not isinstance(line, string_types):
1677 1674 raise TypeError(msg)
1678 1675 return stb
1679 1676
1680 1677 if handler is None:
1681 1678 wrapped = dummy_handler
1682 1679 else:
1683 1680 def wrapped(self,etype,value,tb,tb_offset=None):
1684 1681 """wrap CustomTB handler, to protect IPython from user code
1685 1682
1686 1683 This makes it harder (but not impossible) for custom exception
1687 1684 handlers to crash IPython.
1688 1685 """
1689 1686 try:
1690 1687 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1691 1688 return validate_stb(stb)
1692 1689 except:
1693 1690 # clear custom handler immediately
1694 1691 self.set_custom_exc((), None)
1695 1692 print("Custom TB Handler failed, unregistering", file=sys.stderr)
1696 1693 # show the exception in handler first
1697 1694 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1698 1695 print(self.InteractiveTB.stb2text(stb))
1699 1696 print("The original exception:")
1700 1697 stb = self.InteractiveTB.structured_traceback(
1701 1698 (etype,value,tb), tb_offset=tb_offset
1702 1699 )
1703 1700 return stb
1704 1701
1705 1702 self.CustomTB = types.MethodType(wrapped,self)
1706 1703 self.custom_exceptions = exc_tuple
1707 1704
1708 1705 def excepthook(self, etype, value, tb):
1709 1706 """One more defense for GUI apps that call sys.excepthook.
1710 1707
1711 1708 GUI frameworks like wxPython trap exceptions and call
1712 1709 sys.excepthook themselves. I guess this is a feature that
1713 1710 enables them to keep running after exceptions that would
1714 1711 otherwise kill their mainloop. This is a bother for IPython
1715 1712 which excepts to catch all of the program exceptions with a try:
1716 1713 except: statement.
1717 1714
1718 1715 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1719 1716 any app directly invokes sys.excepthook, it will look to the user like
1720 1717 IPython crashed. In order to work around this, we can disable the
1721 1718 CrashHandler and replace it with this excepthook instead, which prints a
1722 1719 regular traceback using our InteractiveTB. In this fashion, apps which
1723 1720 call sys.excepthook will generate a regular-looking exception from
1724 1721 IPython, and the CrashHandler will only be triggered by real IPython
1725 1722 crashes.
1726 1723
1727 1724 This hook should be used sparingly, only in places which are not likely
1728 1725 to be true IPython errors.
1729 1726 """
1730 1727 self.showtraceback((etype, value, tb), tb_offset=0)
1731 1728
1732 1729 def _get_exc_info(self, exc_tuple=None):
1733 1730 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1734 1731
1735 1732 Ensures sys.last_type,value,traceback hold the exc_info we found,
1736 1733 from whichever source.
1737 1734
1738 1735 raises ValueError if none of these contain any information
1739 1736 """
1740 1737 if exc_tuple is None:
1741 1738 etype, value, tb = sys.exc_info()
1742 1739 else:
1743 1740 etype, value, tb = exc_tuple
1744 1741
1745 1742 if etype is None:
1746 1743 if hasattr(sys, 'last_type'):
1747 1744 etype, value, tb = sys.last_type, sys.last_value, \
1748 1745 sys.last_traceback
1749 1746
1750 1747 if etype is None:
1751 1748 raise ValueError("No exception to find")
1752 1749
1753 1750 # Now store the exception info in sys.last_type etc.
1754 1751 # WARNING: these variables are somewhat deprecated and not
1755 1752 # necessarily safe to use in a threaded environment, but tools
1756 1753 # like pdb depend on their existence, so let's set them. If we
1757 1754 # find problems in the field, we'll need to revisit their use.
1758 1755 sys.last_type = etype
1759 1756 sys.last_value = value
1760 1757 sys.last_traceback = tb
1761 1758
1762 1759 return etype, value, tb
1763 1760
1764 1761 def show_usage_error(self, exc):
1765 1762 """Show a short message for UsageErrors
1766 1763
1767 1764 These are special exceptions that shouldn't show a traceback.
1768 1765 """
1769 1766 print("UsageError: %s" % exc, file=sys.stderr)
1770 1767
1771 1768 def get_exception_only(self, exc_tuple=None):
1772 1769 """
1773 1770 Return as a string (ending with a newline) the exception that
1774 1771 just occurred, without any traceback.
1775 1772 """
1776 1773 etype, value, tb = self._get_exc_info(exc_tuple)
1777 1774 msg = traceback.format_exception_only(etype, value)
1778 1775 return ''.join(msg)
1779 1776
1780 1777 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
1781 1778 exception_only=False):
1782 1779 """Display the exception that just occurred.
1783 1780
1784 1781 If nothing is known about the exception, this is the method which
1785 1782 should be used throughout the code for presenting user tracebacks,
1786 1783 rather than directly invoking the InteractiveTB object.
1787 1784
1788 1785 A specific showsyntaxerror() also exists, but this method can take
1789 1786 care of calling it if needed, so unless you are explicitly catching a
1790 1787 SyntaxError exception, don't try to analyze the stack manually and
1791 1788 simply call this method."""
1792 1789
1793 1790 try:
1794 1791 try:
1795 1792 etype, value, tb = self._get_exc_info(exc_tuple)
1796 1793 except ValueError:
1797 1794 print('No traceback available to show.', file=sys.stderr)
1798 1795 return
1799 1796
1800 1797 if issubclass(etype, SyntaxError):
1801 1798 # Though this won't be called by syntax errors in the input
1802 1799 # line, there may be SyntaxError cases with imported code.
1803 1800 self.showsyntaxerror(filename)
1804 1801 elif etype is UsageError:
1805 1802 self.show_usage_error(value)
1806 1803 else:
1807 1804 if exception_only:
1808 1805 stb = ['An exception has occurred, use %tb to see '
1809 1806 'the full traceback.\n']
1810 1807 stb.extend(self.InteractiveTB.get_exception_only(etype,
1811 1808 value))
1812 1809 else:
1813 1810 try:
1814 1811 # Exception classes can customise their traceback - we
1815 1812 # use this in IPython.parallel for exceptions occurring
1816 1813 # in the engines. This should return a list of strings.
1817 1814 stb = value._render_traceback_()
1818 1815 except Exception:
1819 1816 stb = self.InteractiveTB.structured_traceback(etype,
1820 1817 value, tb, tb_offset=tb_offset)
1821 1818
1822 1819 self._showtraceback(etype, value, stb)
1823 1820 if self.call_pdb:
1824 1821 # drop into debugger
1825 1822 self.debugger(force=True)
1826 1823 return
1827 1824
1828 1825 # Actually show the traceback
1829 1826 self._showtraceback(etype, value, stb)
1830 1827
1831 1828 except KeyboardInterrupt:
1832 1829 print('\n' + self.get_exception_only(), file=sys.stderr)
1833 1830
1834 1831 def _showtraceback(self, etype, evalue, stb):
1835 1832 """Actually show a traceback.
1836 1833
1837 1834 Subclasses may override this method to put the traceback on a different
1838 1835 place, like a side channel.
1839 1836 """
1840 1837 print(self.InteractiveTB.stb2text(stb))
1841 1838
1842 1839 def showsyntaxerror(self, filename=None):
1843 1840 """Display the syntax error that just occurred.
1844 1841
1845 1842 This doesn't display a stack trace because there isn't one.
1846 1843
1847 1844 If a filename is given, it is stuffed in the exception instead
1848 1845 of what was there before (because Python's parser always uses
1849 1846 "<string>" when reading from a string).
1850 1847 """
1851 1848 etype, value, last_traceback = self._get_exc_info()
1852 1849
1853 1850 if filename and issubclass(etype, SyntaxError):
1854 1851 try:
1855 1852 value.filename = filename
1856 1853 except:
1857 1854 # Not the format we expect; leave it alone
1858 1855 pass
1859 1856
1860 1857 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1861 1858 self._showtraceback(etype, value, stb)
1862 1859
1863 1860 # This is overridden in TerminalInteractiveShell to show a message about
1864 1861 # the %paste magic.
1865 1862 def showindentationerror(self):
1866 1863 """Called by run_cell when there's an IndentationError in code entered
1867 1864 at the prompt.
1868 1865
1869 1866 This is overridden in TerminalInteractiveShell to show a message about
1870 1867 the %paste magic."""
1871 1868 self.showsyntaxerror()
1872 1869
1873 1870 #-------------------------------------------------------------------------
1874 1871 # Things related to readline
1875 1872 #-------------------------------------------------------------------------
1876 1873
1877 1874 def init_readline(self):
1878 1875 """Moved to terminal subclass, here only to simplify the init logic."""
1879 1876 self.readline = None
1880 1877 # Set a number of methods that depend on readline to be no-op
1881 1878 self.readline_no_record = NoOpContext()
1882 1879 self.set_readline_completer = no_op
1883 1880 self.set_custom_completer = no_op
1884 1881
1885 1882 @skip_doctest
1886 1883 def set_next_input(self, s, replace=False):
1887 1884 """ Sets the 'default' input string for the next command line.
1888 1885
1889 1886 Example::
1890 1887
1891 1888 In [1]: _ip.set_next_input("Hello Word")
1892 1889 In [2]: Hello Word_ # cursor is here
1893 1890 """
1894 1891 self.rl_next_input = py3compat.cast_bytes_py2(s)
1895 1892
1896 1893 def _indent_current_str(self):
1897 1894 """return the current level of indentation as a string"""
1898 1895 return self.input_splitter.indent_spaces * ' '
1899 1896
1900 1897 #-------------------------------------------------------------------------
1901 1898 # Things related to text completion
1902 1899 #-------------------------------------------------------------------------
1903 1900
1904 1901 def init_completer(self):
1905 1902 """Initialize the completion machinery.
1906 1903
1907 1904 This creates completion machinery that can be used by client code,
1908 1905 either interactively in-process (typically triggered by the readline
1909 1906 library), programmatically (such as in test suites) or out-of-process
1910 1907 (typically over the network by remote frontends).
1911 1908 """
1912 1909 from IPython.core.completer import IPCompleter
1913 1910 from IPython.core.completerlib import (module_completer,
1914 1911 magic_run_completer, cd_completer, reset_completer)
1915 1912
1916 1913 self.Completer = IPCompleter(shell=self,
1917 1914 namespace=self.user_ns,
1918 1915 global_namespace=self.user_global_ns,
1919 1916 use_readline=self.has_readline,
1920 1917 parent=self,
1921 1918 )
1922 1919 self.configurables.append(self.Completer)
1923 1920
1924 1921 # Add custom completers to the basic ones built into IPCompleter
1925 1922 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1926 1923 self.strdispatchers['complete_command'] = sdisp
1927 1924 self.Completer.custom_completers = sdisp
1928 1925
1929 1926 self.set_hook('complete_command', module_completer, str_key = 'import')
1930 1927 self.set_hook('complete_command', module_completer, str_key = 'from')
1931 1928 self.set_hook('complete_command', module_completer, str_key = '%aimport')
1932 1929 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1933 1930 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1934 1931 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1935 1932
1936 1933
1937 1934 @skip_doctest_py2
1938 1935 def complete(self, text, line=None, cursor_pos=None):
1939 1936 """Return the completed text and a list of completions.
1940 1937
1941 1938 Parameters
1942 1939 ----------
1943 1940
1944 1941 text : string
1945 1942 A string of text to be completed on. It can be given as empty and
1946 1943 instead a line/position pair are given. In this case, the
1947 1944 completer itself will split the line like readline does.
1948 1945
1949 1946 line : string, optional
1950 1947 The complete line that text is part of.
1951 1948
1952 1949 cursor_pos : int, optional
1953 1950 The position of the cursor on the input line.
1954 1951
1955 1952 Returns
1956 1953 -------
1957 1954 text : string
1958 1955 The actual text that was completed.
1959 1956
1960 1957 matches : list
1961 1958 A sorted list with all possible completions.
1962 1959
1963 1960 The optional arguments allow the completion to take more context into
1964 1961 account, and are part of the low-level completion API.
1965 1962
1966 1963 This is a wrapper around the completion mechanism, similar to what
1967 1964 readline does at the command line when the TAB key is hit. By
1968 1965 exposing it as a method, it can be used by other non-readline
1969 1966 environments (such as GUIs) for text completion.
1970 1967
1971 1968 Simple usage example:
1972 1969
1973 1970 In [1]: x = 'hello'
1974 1971
1975 1972 In [2]: _ip.complete('x.l')
1976 1973 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1977 1974 """
1978 1975
1979 1976 # Inject names into __builtin__ so we can complete on the added names.
1980 1977 with self.builtin_trap:
1981 1978 return self.Completer.complete(text, line, cursor_pos)
1982 1979
1983 1980 def set_custom_completer(self, completer, pos=0):
1984 1981 """Adds a new custom completer function.
1985 1982
1986 1983 The position argument (defaults to 0) is the index in the completers
1987 1984 list where you want the completer to be inserted."""
1988 1985
1989 1986 newcomp = types.MethodType(completer,self.Completer)
1990 1987 self.Completer.matchers.insert(pos,newcomp)
1991 1988
1992 1989 def set_completer_frame(self, frame=None):
1993 1990 """Set the frame of the completer."""
1994 1991 if frame:
1995 1992 self.Completer.namespace = frame.f_locals
1996 1993 self.Completer.global_namespace = frame.f_globals
1997 1994 else:
1998 1995 self.Completer.namespace = self.user_ns
1999 1996 self.Completer.global_namespace = self.user_global_ns
2000 1997
2001 1998 #-------------------------------------------------------------------------
2002 1999 # Things related to magics
2003 2000 #-------------------------------------------------------------------------
2004 2001
2005 2002 def init_magics(self):
2006 2003 from IPython.core import magics as m
2007 2004 self.magics_manager = magic.MagicsManager(shell=self,
2008 2005 parent=self,
2009 2006 user_magics=m.UserMagics(self))
2010 2007 self.configurables.append(self.magics_manager)
2011 2008
2012 2009 # Expose as public API from the magics manager
2013 2010 self.register_magics = self.magics_manager.register
2014 2011
2015 2012 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2016 2013 m.ConfigMagics, m.DisplayMagics, m.ExecutionMagics,
2017 2014 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2018 2015 m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
2019 2016 )
2020 2017
2021 2018 # Register Magic Aliases
2022 2019 mman = self.magics_manager
2023 2020 # FIXME: magic aliases should be defined by the Magics classes
2024 2021 # or in MagicsManager, not here
2025 2022 mman.register_alias('ed', 'edit')
2026 2023 mman.register_alias('hist', 'history')
2027 2024 mman.register_alias('rep', 'recall')
2028 2025 mman.register_alias('SVG', 'svg', 'cell')
2029 2026 mman.register_alias('HTML', 'html', 'cell')
2030 2027 mman.register_alias('file', 'writefile', 'cell')
2031 2028
2032 2029 # FIXME: Move the color initialization to the DisplayHook, which
2033 2030 # should be split into a prompt manager and displayhook. We probably
2034 2031 # even need a centralize colors management object.
2035 2032 self.magic('colors %s' % self.colors)
2036 2033
2037 2034 # Defined here so that it's included in the documentation
2038 2035 @functools.wraps(magic.MagicsManager.register_function)
2039 2036 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2040 2037 self.magics_manager.register_function(func,
2041 2038 magic_kind=magic_kind, magic_name=magic_name)
2042 2039
2043 2040 def run_line_magic(self, magic_name, line):
2044 2041 """Execute the given line magic.
2045 2042
2046 2043 Parameters
2047 2044 ----------
2048 2045 magic_name : str
2049 2046 Name of the desired magic function, without '%' prefix.
2050 2047
2051 2048 line : str
2052 2049 The rest of the input line as a single string.
2053 2050 """
2054 2051 fn = self.find_line_magic(magic_name)
2055 2052 if fn is None:
2056 2053 cm = self.find_cell_magic(magic_name)
2057 2054 etpl = "Line magic function `%%%s` not found%s."
2058 2055 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2059 2056 'did you mean that instead?)' % magic_name )
2060 2057 error(etpl % (magic_name, extra))
2061 2058 else:
2062 2059 # Note: this is the distance in the stack to the user's frame.
2063 2060 # This will need to be updated if the internal calling logic gets
2064 2061 # refactored, or else we'll be expanding the wrong variables.
2065 2062 stack_depth = 2
2066 2063 magic_arg_s = self.var_expand(line, stack_depth)
2067 2064 # Put magic args in a list so we can call with f(*a) syntax
2068 2065 args = [magic_arg_s]
2069 2066 kwargs = {}
2070 2067 # Grab local namespace if we need it:
2071 2068 if getattr(fn, "needs_local_scope", False):
2072 2069 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
2073 2070 with self.builtin_trap:
2074 2071 result = fn(*args,**kwargs)
2075 2072 return result
2076 2073
2077 2074 def run_cell_magic(self, magic_name, line, cell):
2078 2075 """Execute the given cell magic.
2079 2076
2080 2077 Parameters
2081 2078 ----------
2082 2079 magic_name : str
2083 2080 Name of the desired magic function, without '%' prefix.
2084 2081
2085 2082 line : str
2086 2083 The rest of the first input line as a single string.
2087 2084
2088 2085 cell : str
2089 2086 The body of the cell as a (possibly multiline) string.
2090 2087 """
2091 2088 fn = self.find_cell_magic(magic_name)
2092 2089 if fn is None:
2093 2090 lm = self.find_line_magic(magic_name)
2094 2091 etpl = "Cell magic `%%{0}` not found{1}."
2095 2092 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2096 2093 'did you mean that instead?)'.format(magic_name))
2097 2094 error(etpl.format(magic_name, extra))
2098 2095 elif cell == '':
2099 2096 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2100 2097 if self.find_line_magic(magic_name) is not None:
2101 2098 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2102 2099 raise UsageError(message)
2103 2100 else:
2104 2101 # Note: this is the distance in the stack to the user's frame.
2105 2102 # This will need to be updated if the internal calling logic gets
2106 2103 # refactored, or else we'll be expanding the wrong variables.
2107 2104 stack_depth = 2
2108 2105 magic_arg_s = self.var_expand(line, stack_depth)
2109 2106 with self.builtin_trap:
2110 2107 result = fn(magic_arg_s, cell)
2111 2108 return result
2112 2109
2113 2110 def find_line_magic(self, magic_name):
2114 2111 """Find and return a line magic by name.
2115 2112
2116 2113 Returns None if the magic isn't found."""
2117 2114 return self.magics_manager.magics['line'].get(magic_name)
2118 2115
2119 2116 def find_cell_magic(self, magic_name):
2120 2117 """Find and return a cell magic by name.
2121 2118
2122 2119 Returns None if the magic isn't found."""
2123 2120 return self.magics_manager.magics['cell'].get(magic_name)
2124 2121
2125 2122 def find_magic(self, magic_name, magic_kind='line'):
2126 2123 """Find and return a magic of the given type by name.
2127 2124
2128 2125 Returns None if the magic isn't found."""
2129 2126 return self.magics_manager.magics[magic_kind].get(magic_name)
2130 2127
2131 2128 def magic(self, arg_s):
2132 2129 """DEPRECATED. Use run_line_magic() instead.
2133 2130
2134 2131 Call a magic function by name.
2135 2132
2136 2133 Input: a string containing the name of the magic function to call and
2137 2134 any additional arguments to be passed to the magic.
2138 2135
2139 2136 magic('name -opt foo bar') is equivalent to typing at the ipython
2140 2137 prompt:
2141 2138
2142 2139 In[1]: %name -opt foo bar
2143 2140
2144 2141 To call a magic without arguments, simply use magic('name').
2145 2142
2146 2143 This provides a proper Python function to call IPython's magics in any
2147 2144 valid Python code you can type at the interpreter, including loops and
2148 2145 compound statements.
2149 2146 """
2150 2147 # TODO: should we issue a loud deprecation warning here?
2151 2148 magic_name, _, magic_arg_s = arg_s.partition(' ')
2152 2149 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2153 2150 return self.run_line_magic(magic_name, magic_arg_s)
2154 2151
2155 2152 #-------------------------------------------------------------------------
2156 2153 # Things related to macros
2157 2154 #-------------------------------------------------------------------------
2158 2155
2159 2156 def define_macro(self, name, themacro):
2160 2157 """Define a new macro
2161 2158
2162 2159 Parameters
2163 2160 ----------
2164 2161 name : str
2165 2162 The name of the macro.
2166 2163 themacro : str or Macro
2167 2164 The action to do upon invoking the macro. If a string, a new
2168 2165 Macro object is created by passing the string to it.
2169 2166 """
2170 2167
2171 2168 from IPython.core import macro
2172 2169
2173 2170 if isinstance(themacro, string_types):
2174 2171 themacro = macro.Macro(themacro)
2175 2172 if not isinstance(themacro, macro.Macro):
2176 2173 raise ValueError('A macro must be a string or a Macro instance.')
2177 2174 self.user_ns[name] = themacro
2178 2175
2179 2176 #-------------------------------------------------------------------------
2180 2177 # Things related to the running of system commands
2181 2178 #-------------------------------------------------------------------------
2182 2179
2183 2180 def system_piped(self, cmd):
2184 2181 """Call the given cmd in a subprocess, piping stdout/err
2185 2182
2186 2183 Parameters
2187 2184 ----------
2188 2185 cmd : str
2189 2186 Command to execute (can not end in '&', as background processes are
2190 2187 not supported. Should not be a command that expects input
2191 2188 other than simple text.
2192 2189 """
2193 2190 if cmd.rstrip().endswith('&'):
2194 2191 # this is *far* from a rigorous test
2195 2192 # We do not support backgrounding processes because we either use
2196 2193 # pexpect or pipes to read from. Users can always just call
2197 2194 # os.system() or use ip.system=ip.system_raw
2198 2195 # if they really want a background process.
2199 2196 raise OSError("Background processes not supported.")
2200 2197
2201 2198 # we explicitly do NOT return the subprocess status code, because
2202 2199 # a non-None value would trigger :func:`sys.displayhook` calls.
2203 2200 # Instead, we store the exit_code in user_ns.
2204 2201 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2205 2202
2206 2203 def system_raw(self, cmd):
2207 2204 """Call the given cmd in a subprocess using os.system on Windows or
2208 2205 subprocess.call using the system shell on other platforms.
2209 2206
2210 2207 Parameters
2211 2208 ----------
2212 2209 cmd : str
2213 2210 Command to execute.
2214 2211 """
2215 2212 cmd = self.var_expand(cmd, depth=1)
2216 2213 # protect os.system from UNC paths on Windows, which it can't handle:
2217 2214 if sys.platform == 'win32':
2218 2215 from IPython.utils._process_win32 import AvoidUNCPath
2219 2216 with AvoidUNCPath() as path:
2220 2217 if path is not None:
2221 2218 cmd = '"pushd %s &&"%s' % (path, cmd)
2222 2219 cmd = py3compat.unicode_to_str(cmd)
2223 2220 try:
2224 2221 ec = os.system(cmd)
2225 2222 except KeyboardInterrupt:
2226 2223 print('\n' + self.get_exception_only(), file=sys.stderr)
2227 2224 ec = -2
2228 2225 else:
2229 2226 cmd = py3compat.unicode_to_str(cmd)
2230 2227 # For posix the result of the subprocess.call() below is an exit
2231 2228 # code, which by convention is zero for success, positive for
2232 2229 # program failure. Exit codes above 128 are reserved for signals,
2233 2230 # and the formula for converting a signal to an exit code is usually
2234 2231 # signal_number+128. To more easily differentiate between exit
2235 2232 # codes and signals, ipython uses negative numbers. For instance
2236 2233 # since control-c is signal 2 but exit code 130, ipython's
2237 2234 # _exit_code variable will read -2. Note that some shells like
2238 2235 # csh and fish don't follow sh/bash conventions for exit codes.
2239 2236 executable = os.environ.get('SHELL', None)
2240 2237 try:
2241 2238 # Use env shell instead of default /bin/sh
2242 2239 ec = subprocess.call(cmd, shell=True, executable=executable)
2243 2240 except KeyboardInterrupt:
2244 2241 # intercept control-C; a long traceback is not useful here
2245 2242 print('\n' + self.get_exception_only(), file=sys.stderr)
2246 2243 ec = 130
2247 2244 if ec > 128:
2248 2245 ec = -(ec - 128)
2249 2246
2250 2247 # We explicitly do NOT return the subprocess status code, because
2251 2248 # a non-None value would trigger :func:`sys.displayhook` calls.
2252 2249 # Instead, we store the exit_code in user_ns. Note the semantics
2253 2250 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2254 2251 # but raising SystemExit(_exit_code) will give status 254!
2255 2252 self.user_ns['_exit_code'] = ec
2256 2253
2257 2254 # use piped system by default, because it is better behaved
2258 2255 system = system_piped
2259 2256
2260 2257 def getoutput(self, cmd, split=True, depth=0):
2261 2258 """Get output (possibly including stderr) from a subprocess.
2262 2259
2263 2260 Parameters
2264 2261 ----------
2265 2262 cmd : str
2266 2263 Command to execute (can not end in '&', as background processes are
2267 2264 not supported.
2268 2265 split : bool, optional
2269 2266 If True, split the output into an IPython SList. Otherwise, an
2270 2267 IPython LSString is returned. These are objects similar to normal
2271 2268 lists and strings, with a few convenience attributes for easier
2272 2269 manipulation of line-based output. You can use '?' on them for
2273 2270 details.
2274 2271 depth : int, optional
2275 2272 How many frames above the caller are the local variables which should
2276 2273 be expanded in the command string? The default (0) assumes that the
2277 2274 expansion variables are in the stack frame calling this function.
2278 2275 """
2279 2276 if cmd.rstrip().endswith('&'):
2280 2277 # this is *far* from a rigorous test
2281 2278 raise OSError("Background processes not supported.")
2282 2279 out = getoutput(self.var_expand(cmd, depth=depth+1))
2283 2280 if split:
2284 2281 out = SList(out.splitlines())
2285 2282 else:
2286 2283 out = LSString(out)
2287 2284 return out
2288 2285
2289 2286 #-------------------------------------------------------------------------
2290 2287 # Things related to aliases
2291 2288 #-------------------------------------------------------------------------
2292 2289
2293 2290 def init_alias(self):
2294 2291 self.alias_manager = AliasManager(shell=self, parent=self)
2295 2292 self.configurables.append(self.alias_manager)
2296 2293
2297 2294 #-------------------------------------------------------------------------
2298 2295 # Things related to extensions
2299 2296 #-------------------------------------------------------------------------
2300 2297
2301 2298 def init_extension_manager(self):
2302 2299 self.extension_manager = ExtensionManager(shell=self, parent=self)
2303 2300 self.configurables.append(self.extension_manager)
2304 2301
2305 2302 #-------------------------------------------------------------------------
2306 2303 # Things related to payloads
2307 2304 #-------------------------------------------------------------------------
2308 2305
2309 2306 def init_payload(self):
2310 2307 self.payload_manager = PayloadManager(parent=self)
2311 2308 self.configurables.append(self.payload_manager)
2312 2309
2313 2310 #-------------------------------------------------------------------------
2314 2311 # Things related to the prefilter
2315 2312 #-------------------------------------------------------------------------
2316 2313
2317 2314 def init_prefilter(self):
2318 2315 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2319 2316 self.configurables.append(self.prefilter_manager)
2320 2317 # Ultimately this will be refactored in the new interpreter code, but
2321 2318 # for now, we should expose the main prefilter method (there's legacy
2322 2319 # code out there that may rely on this).
2323 2320 self.prefilter = self.prefilter_manager.prefilter_lines
2324 2321
2325 2322 def auto_rewrite_input(self, cmd):
2326 2323 """Print to the screen the rewritten form of the user's command.
2327 2324
2328 2325 This shows visual feedback by rewriting input lines that cause
2329 2326 automatic calling to kick in, like::
2330 2327
2331 2328 /f x
2332 2329
2333 2330 into::
2334 2331
2335 2332 ------> f(x)
2336 2333
2337 2334 after the user's input prompt. This helps the user understand that the
2338 2335 input line was transformed automatically by IPython.
2339 2336 """
2340 2337 if not self.show_rewritten_input:
2341 2338 return
2342
2343 rw = self.prompt_manager.render('rewrite') + cmd
2344 2339
2345 try:
2346 # plain ascii works better w/ pyreadline, on some machines, so
2347 # we use it and only print uncolored rewrite if we have unicode
2348 rw = str(rw)
2349 print(rw)
2350 except UnicodeEncodeError:
2351 print("------> " + cmd)
2340 # This is overridden in TerminalInteractiveShell to use fancy prompts
2341 print("------> " + cmd)
2352 2342
2353 2343 #-------------------------------------------------------------------------
2354 2344 # Things related to extracting values/expressions from kernel and user_ns
2355 2345 #-------------------------------------------------------------------------
2356 2346
2357 2347 def _user_obj_error(self):
2358 2348 """return simple exception dict
2359 2349
2360 2350 for use in user_expressions
2361 2351 """
2362 2352
2363 2353 etype, evalue, tb = self._get_exc_info()
2364 2354 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2365 2355
2366 2356 exc_info = {
2367 2357 u'status' : 'error',
2368 2358 u'traceback' : stb,
2369 2359 u'ename' : unicode_type(etype.__name__),
2370 2360 u'evalue' : py3compat.safe_unicode(evalue),
2371 2361 }
2372 2362
2373 2363 return exc_info
2374 2364
2375 2365 def _format_user_obj(self, obj):
2376 2366 """format a user object to display dict
2377 2367
2378 2368 for use in user_expressions
2379 2369 """
2380 2370
2381 2371 data, md = self.display_formatter.format(obj)
2382 2372 value = {
2383 2373 'status' : 'ok',
2384 2374 'data' : data,
2385 2375 'metadata' : md,
2386 2376 }
2387 2377 return value
2388 2378
2389 2379 def user_expressions(self, expressions):
2390 2380 """Evaluate a dict of expressions in the user's namespace.
2391 2381
2392 2382 Parameters
2393 2383 ----------
2394 2384 expressions : dict
2395 2385 A dict with string keys and string values. The expression values
2396 2386 should be valid Python expressions, each of which will be evaluated
2397 2387 in the user namespace.
2398 2388
2399 2389 Returns
2400 2390 -------
2401 2391 A dict, keyed like the input expressions dict, with the rich mime-typed
2402 2392 display_data of each value.
2403 2393 """
2404 2394 out = {}
2405 2395 user_ns = self.user_ns
2406 2396 global_ns = self.user_global_ns
2407 2397
2408 2398 for key, expr in iteritems(expressions):
2409 2399 try:
2410 2400 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2411 2401 except:
2412 2402 value = self._user_obj_error()
2413 2403 out[key] = value
2414 2404 return out
2415 2405
2416 2406 #-------------------------------------------------------------------------
2417 2407 # Things related to the running of code
2418 2408 #-------------------------------------------------------------------------
2419 2409
2420 2410 def ex(self, cmd):
2421 2411 """Execute a normal python statement in user namespace."""
2422 2412 with self.builtin_trap:
2423 2413 exec(cmd, self.user_global_ns, self.user_ns)
2424 2414
2425 2415 def ev(self, expr):
2426 2416 """Evaluate python expression expr in user namespace.
2427 2417
2428 2418 Returns the result of evaluation
2429 2419 """
2430 2420 with self.builtin_trap:
2431 2421 return eval(expr, self.user_global_ns, self.user_ns)
2432 2422
2433 2423 def safe_execfile(self, fname, *where, **kw):
2434 2424 """A safe version of the builtin execfile().
2435 2425
2436 2426 This version will never throw an exception, but instead print
2437 2427 helpful error messages to the screen. This only works on pure
2438 2428 Python files with the .py extension.
2439 2429
2440 2430 Parameters
2441 2431 ----------
2442 2432 fname : string
2443 2433 The name of the file to be executed.
2444 2434 where : tuple
2445 2435 One or two namespaces, passed to execfile() as (globals,locals).
2446 2436 If only one is given, it is passed as both.
2447 2437 exit_ignore : bool (False)
2448 2438 If True, then silence SystemExit for non-zero status (it is always
2449 2439 silenced for zero status, as it is so common).
2450 2440 raise_exceptions : bool (False)
2451 2441 If True raise exceptions everywhere. Meant for testing.
2452 2442 shell_futures : bool (False)
2453 2443 If True, the code will share future statements with the interactive
2454 2444 shell. It will both be affected by previous __future__ imports, and
2455 2445 any __future__ imports in the code will affect the shell. If False,
2456 2446 __future__ imports are not shared in either direction.
2457 2447
2458 2448 """
2459 2449 kw.setdefault('exit_ignore', False)
2460 2450 kw.setdefault('raise_exceptions', False)
2461 2451 kw.setdefault('shell_futures', False)
2462 2452
2463 2453 fname = os.path.abspath(os.path.expanduser(fname))
2464 2454
2465 2455 # Make sure we can open the file
2466 2456 try:
2467 2457 with open(fname):
2468 2458 pass
2469 2459 except:
2470 2460 warn('Could not open file <%s> for safe execution.' % fname)
2471 2461 return
2472 2462
2473 2463 # Find things also in current directory. This is needed to mimic the
2474 2464 # behavior of running a script from the system command line, where
2475 2465 # Python inserts the script's directory into sys.path
2476 2466 dname = os.path.dirname(fname)
2477 2467
2478 2468 with prepended_to_syspath(dname):
2479 2469 try:
2480 2470 glob, loc = (where + (None, ))[:2]
2481 2471 py3compat.execfile(
2482 2472 fname, glob, loc,
2483 2473 self.compile if kw['shell_futures'] else None)
2484 2474 except SystemExit as status:
2485 2475 # If the call was made with 0 or None exit status (sys.exit(0)
2486 2476 # or sys.exit() ), don't bother showing a traceback, as both of
2487 2477 # these are considered normal by the OS:
2488 2478 # > python -c'import sys;sys.exit(0)'; echo $?
2489 2479 # 0
2490 2480 # > python -c'import sys;sys.exit()'; echo $?
2491 2481 # 0
2492 2482 # For other exit status, we show the exception unless
2493 2483 # explicitly silenced, but only in short form.
2494 2484 if status.code:
2495 2485 if kw['raise_exceptions']:
2496 2486 raise
2497 2487 if not kw['exit_ignore']:
2498 2488 self.showtraceback(exception_only=True)
2499 2489 except:
2500 2490 if kw['raise_exceptions']:
2501 2491 raise
2502 2492 # tb offset is 2 because we wrap execfile
2503 2493 self.showtraceback(tb_offset=2)
2504 2494
2505 2495 def safe_execfile_ipy(self, fname, shell_futures=False, raise_exceptions=False):
2506 2496 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2507 2497
2508 2498 Parameters
2509 2499 ----------
2510 2500 fname : str
2511 2501 The name of the file to execute. The filename must have a
2512 2502 .ipy or .ipynb extension.
2513 2503 shell_futures : bool (False)
2514 2504 If True, the code will share future statements with the interactive
2515 2505 shell. It will both be affected by previous __future__ imports, and
2516 2506 any __future__ imports in the code will affect the shell. If False,
2517 2507 __future__ imports are not shared in either direction.
2518 2508 raise_exceptions : bool (False)
2519 2509 If True raise exceptions everywhere. Meant for testing.
2520 2510 """
2521 2511 fname = os.path.abspath(os.path.expanduser(fname))
2522 2512
2523 2513 # Make sure we can open the file
2524 2514 try:
2525 2515 with open(fname):
2526 2516 pass
2527 2517 except:
2528 2518 warn('Could not open file <%s> for safe execution.' % fname)
2529 2519 return
2530 2520
2531 2521 # Find things also in current directory. This is needed to mimic the
2532 2522 # behavior of running a script from the system command line, where
2533 2523 # Python inserts the script's directory into sys.path
2534 2524 dname = os.path.dirname(fname)
2535 2525
2536 2526 def get_cells():
2537 2527 """generator for sequence of code blocks to run"""
2538 2528 if fname.endswith('.ipynb'):
2539 2529 from nbformat import read
2540 2530 with io_open(fname) as f:
2541 2531 nb = read(f, as_version=4)
2542 2532 if not nb.cells:
2543 2533 return
2544 2534 for cell in nb.cells:
2545 2535 if cell.cell_type == 'code':
2546 2536 yield cell.source
2547 2537 else:
2548 2538 with open(fname) as f:
2549 2539 yield f.read()
2550 2540
2551 2541 with prepended_to_syspath(dname):
2552 2542 try:
2553 2543 for cell in get_cells():
2554 2544 result = self.run_cell(cell, silent=True, shell_futures=shell_futures)
2555 2545 if raise_exceptions:
2556 2546 result.raise_error()
2557 2547 elif not result.success:
2558 2548 break
2559 2549 except:
2560 2550 if raise_exceptions:
2561 2551 raise
2562 2552 self.showtraceback()
2563 2553 warn('Unknown failure executing file: <%s>' % fname)
2564 2554
2565 2555 def safe_run_module(self, mod_name, where):
2566 2556 """A safe version of runpy.run_module().
2567 2557
2568 2558 This version will never throw an exception, but instead print
2569 2559 helpful error messages to the screen.
2570 2560
2571 2561 `SystemExit` exceptions with status code 0 or None are ignored.
2572 2562
2573 2563 Parameters
2574 2564 ----------
2575 2565 mod_name : string
2576 2566 The name of the module to be executed.
2577 2567 where : dict
2578 2568 The globals namespace.
2579 2569 """
2580 2570 try:
2581 2571 try:
2582 2572 where.update(
2583 2573 runpy.run_module(str(mod_name), run_name="__main__",
2584 2574 alter_sys=True)
2585 2575 )
2586 2576 except SystemExit as status:
2587 2577 if status.code:
2588 2578 raise
2589 2579 except:
2590 2580 self.showtraceback()
2591 2581 warn('Unknown failure executing module: <%s>' % mod_name)
2592 2582
2593 2583 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2594 2584 """Run a complete IPython cell.
2595 2585
2596 2586 Parameters
2597 2587 ----------
2598 2588 raw_cell : str
2599 2589 The code (including IPython code such as %magic functions) to run.
2600 2590 store_history : bool
2601 2591 If True, the raw and translated cell will be stored in IPython's
2602 2592 history. For user code calling back into IPython's machinery, this
2603 2593 should be set to False.
2604 2594 silent : bool
2605 2595 If True, avoid side-effects, such as implicit displayhooks and
2606 2596 and logging. silent=True forces store_history=False.
2607 2597 shell_futures : bool
2608 2598 If True, the code will share future statements with the interactive
2609 2599 shell. It will both be affected by previous __future__ imports, and
2610 2600 any __future__ imports in the code will affect the shell. If False,
2611 2601 __future__ imports are not shared in either direction.
2612 2602
2613 2603 Returns
2614 2604 -------
2615 2605 result : :class:`ExecutionResult`
2616 2606 """
2617 2607 result = ExecutionResult()
2618 2608
2619 2609 if (not raw_cell) or raw_cell.isspace():
2620 2610 return result
2621 2611
2622 2612 if silent:
2623 2613 store_history = False
2624 2614
2625 2615 if store_history:
2626 2616 result.execution_count = self.execution_count
2627 2617
2628 2618 def error_before_exec(value):
2629 2619 result.error_before_exec = value
2630 2620 return result
2631 2621
2632 2622 self.events.trigger('pre_execute')
2633 2623 if not silent:
2634 2624 self.events.trigger('pre_run_cell')
2635 2625
2636 2626 # If any of our input transformation (input_transformer_manager or
2637 2627 # prefilter_manager) raises an exception, we store it in this variable
2638 2628 # so that we can display the error after logging the input and storing
2639 2629 # it in the history.
2640 2630 preprocessing_exc_tuple = None
2641 2631 try:
2642 2632 # Static input transformations
2643 2633 cell = self.input_transformer_manager.transform_cell(raw_cell)
2644 2634 except SyntaxError:
2645 2635 preprocessing_exc_tuple = sys.exc_info()
2646 2636 cell = raw_cell # cell has to exist so it can be stored/logged
2647 2637 else:
2648 2638 if len(cell.splitlines()) == 1:
2649 2639 # Dynamic transformations - only applied for single line commands
2650 2640 with self.builtin_trap:
2651 2641 try:
2652 2642 # use prefilter_lines to handle trailing newlines
2653 2643 # restore trailing newline for ast.parse
2654 2644 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2655 2645 except Exception:
2656 2646 # don't allow prefilter errors to crash IPython
2657 2647 preprocessing_exc_tuple = sys.exc_info()
2658 2648
2659 2649 # Store raw and processed history
2660 2650 if store_history:
2661 2651 self.history_manager.store_inputs(self.execution_count,
2662 2652 cell, raw_cell)
2663 2653 if not silent:
2664 2654 self.logger.log(cell, raw_cell)
2665 2655
2666 2656 # Display the exception if input processing failed.
2667 2657 if preprocessing_exc_tuple is not None:
2668 2658 self.showtraceback(preprocessing_exc_tuple)
2669 2659 if store_history:
2670 2660 self.execution_count += 1
2671 2661 return error_before_exec(preprocessing_exc_tuple[2])
2672 2662
2673 2663 # Our own compiler remembers the __future__ environment. If we want to
2674 2664 # run code with a separate __future__ environment, use the default
2675 2665 # compiler
2676 2666 compiler = self.compile if shell_futures else CachingCompiler()
2677 2667
2678 2668 with self.builtin_trap:
2679 2669 cell_name = self.compile.cache(cell, self.execution_count)
2680 2670
2681 2671 with self.display_trap:
2682 2672 # Compile to bytecode
2683 2673 try:
2684 2674 code_ast = compiler.ast_parse(cell, filename=cell_name)
2685 2675 except self.custom_exceptions as e:
2686 2676 etype, value, tb = sys.exc_info()
2687 2677 self.CustomTB(etype, value, tb)
2688 2678 return error_before_exec(e)
2689 2679 except IndentationError as e:
2690 2680 self.showindentationerror()
2691 2681 if store_history:
2692 2682 self.execution_count += 1
2693 2683 return error_before_exec(e)
2694 2684 except (OverflowError, SyntaxError, ValueError, TypeError,
2695 2685 MemoryError) as e:
2696 2686 self.showsyntaxerror()
2697 2687 if store_history:
2698 2688 self.execution_count += 1
2699 2689 return error_before_exec(e)
2700 2690
2701 2691 # Apply AST transformations
2702 2692 try:
2703 2693 code_ast = self.transform_ast(code_ast)
2704 2694 except InputRejected as e:
2705 2695 self.showtraceback()
2706 2696 if store_history:
2707 2697 self.execution_count += 1
2708 2698 return error_before_exec(e)
2709 2699
2710 2700 # Give the displayhook a reference to our ExecutionResult so it
2711 2701 # can fill in the output value.
2712 2702 self.displayhook.exec_result = result
2713 2703
2714 2704 # Execute the user code
2715 2705 interactivity = "none" if silent else self.ast_node_interactivity
2716 2706 self.run_ast_nodes(code_ast.body, cell_name,
2717 2707 interactivity=interactivity, compiler=compiler, result=result)
2718 2708
2719 2709 # Reset this so later displayed values do not modify the
2720 2710 # ExecutionResult
2721 2711 self.displayhook.exec_result = None
2722 2712
2723 2713 self.events.trigger('post_execute')
2724 2714 if not silent:
2725 2715 self.events.trigger('post_run_cell')
2726 2716
2727 2717 if store_history:
2728 2718 # Write output to the database. Does nothing unless
2729 2719 # history output logging is enabled.
2730 2720 self.history_manager.store_output(self.execution_count)
2731 2721 # Each cell is a *single* input, regardless of how many lines it has
2732 2722 self.execution_count += 1
2733 2723
2734 2724 return result
2735 2725
2736 2726 def transform_ast(self, node):
2737 2727 """Apply the AST transformations from self.ast_transformers
2738 2728
2739 2729 Parameters
2740 2730 ----------
2741 2731 node : ast.Node
2742 2732 The root node to be transformed. Typically called with the ast.Module
2743 2733 produced by parsing user input.
2744 2734
2745 2735 Returns
2746 2736 -------
2747 2737 An ast.Node corresponding to the node it was called with. Note that it
2748 2738 may also modify the passed object, so don't rely on references to the
2749 2739 original AST.
2750 2740 """
2751 2741 for transformer in self.ast_transformers:
2752 2742 try:
2753 2743 node = transformer.visit(node)
2754 2744 except InputRejected:
2755 2745 # User-supplied AST transformers can reject an input by raising
2756 2746 # an InputRejected. Short-circuit in this case so that we
2757 2747 # don't unregister the transform.
2758 2748 raise
2759 2749 except Exception:
2760 2750 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
2761 2751 self.ast_transformers.remove(transformer)
2762 2752
2763 2753 if self.ast_transformers:
2764 2754 ast.fix_missing_locations(node)
2765 2755 return node
2766 2756
2767 2757
2768 2758 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr',
2769 2759 compiler=compile, result=None):
2770 2760 """Run a sequence of AST nodes. The execution mode depends on the
2771 2761 interactivity parameter.
2772 2762
2773 2763 Parameters
2774 2764 ----------
2775 2765 nodelist : list
2776 2766 A sequence of AST nodes to run.
2777 2767 cell_name : str
2778 2768 Will be passed to the compiler as the filename of the cell. Typically
2779 2769 the value returned by ip.compile.cache(cell).
2780 2770 interactivity : str
2781 2771 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2782 2772 run interactively (displaying output from expressions). 'last_expr'
2783 2773 will run the last node interactively only if it is an expression (i.e.
2784 2774 expressions in loops or other blocks are not displayed. Other values
2785 2775 for this parameter will raise a ValueError.
2786 2776 compiler : callable
2787 2777 A function with the same interface as the built-in compile(), to turn
2788 2778 the AST nodes into code objects. Default is the built-in compile().
2789 2779 result : ExecutionResult, optional
2790 2780 An object to store exceptions that occur during execution.
2791 2781
2792 2782 Returns
2793 2783 -------
2794 2784 True if an exception occurred while running code, False if it finished
2795 2785 running.
2796 2786 """
2797 2787 if not nodelist:
2798 2788 return
2799 2789
2800 2790 if interactivity == 'last_expr':
2801 2791 if isinstance(nodelist[-1], ast.Expr):
2802 2792 interactivity = "last"
2803 2793 else:
2804 2794 interactivity = "none"
2805 2795
2806 2796 if interactivity == 'none':
2807 2797 to_run_exec, to_run_interactive = nodelist, []
2808 2798 elif interactivity == 'last':
2809 2799 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2810 2800 elif interactivity == 'all':
2811 2801 to_run_exec, to_run_interactive = [], nodelist
2812 2802 else:
2813 2803 raise ValueError("Interactivity was %r" % interactivity)
2814 2804
2815 2805 try:
2816 2806 for i, node in enumerate(to_run_exec):
2817 2807 mod = ast.Module([node])
2818 2808 code = compiler(mod, cell_name, "exec")
2819 2809 if self.run_code(code, result):
2820 2810 return True
2821 2811
2822 2812 for i, node in enumerate(to_run_interactive):
2823 2813 mod = ast.Interactive([node])
2824 2814 code = compiler(mod, cell_name, "single")
2825 2815 if self.run_code(code, result):
2826 2816 return True
2827 2817
2828 2818 # Flush softspace
2829 2819 if softspace(sys.stdout, 0):
2830 2820 print()
2831 2821
2832 2822 except:
2833 2823 # It's possible to have exceptions raised here, typically by
2834 2824 # compilation of odd code (such as a naked 'return' outside a
2835 2825 # function) that did parse but isn't valid. Typically the exception
2836 2826 # is a SyntaxError, but it's safest just to catch anything and show
2837 2827 # the user a traceback.
2838 2828
2839 2829 # We do only one try/except outside the loop to minimize the impact
2840 2830 # on runtime, and also because if any node in the node list is
2841 2831 # broken, we should stop execution completely.
2842 2832 if result:
2843 2833 result.error_before_exec = sys.exc_info()[1]
2844 2834 self.showtraceback()
2845 2835 return True
2846 2836
2847 2837 return False
2848 2838
2849 2839 def run_code(self, code_obj, result=None):
2850 2840 """Execute a code object.
2851 2841
2852 2842 When an exception occurs, self.showtraceback() is called to display a
2853 2843 traceback.
2854 2844
2855 2845 Parameters
2856 2846 ----------
2857 2847 code_obj : code object
2858 2848 A compiled code object, to be executed
2859 2849 result : ExecutionResult, optional
2860 2850 An object to store exceptions that occur during execution.
2861 2851
2862 2852 Returns
2863 2853 -------
2864 2854 False : successful execution.
2865 2855 True : an error occurred.
2866 2856 """
2867 2857 # Set our own excepthook in case the user code tries to call it
2868 2858 # directly, so that the IPython crash handler doesn't get triggered
2869 2859 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
2870 2860
2871 2861 # we save the original sys.excepthook in the instance, in case config
2872 2862 # code (such as magics) needs access to it.
2873 2863 self.sys_excepthook = old_excepthook
2874 2864 outflag = 1 # happens in more places, so it's easier as default
2875 2865 try:
2876 2866 try:
2877 2867 self.hooks.pre_run_code_hook()
2878 2868 #rprint('Running code', repr(code_obj)) # dbg
2879 2869 exec(code_obj, self.user_global_ns, self.user_ns)
2880 2870 finally:
2881 2871 # Reset our crash handler in place
2882 2872 sys.excepthook = old_excepthook
2883 2873 except SystemExit as e:
2884 2874 if result is not None:
2885 2875 result.error_in_exec = e
2886 2876 self.showtraceback(exception_only=True)
2887 2877 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2888 2878 except self.custom_exceptions:
2889 2879 etype, value, tb = sys.exc_info()
2890 2880 if result is not None:
2891 2881 result.error_in_exec = value
2892 2882 self.CustomTB(etype, value, tb)
2893 2883 except:
2894 2884 if result is not None:
2895 2885 result.error_in_exec = sys.exc_info()[1]
2896 2886 self.showtraceback()
2897 2887 else:
2898 2888 outflag = 0
2899 2889 return outflag
2900 2890
2901 2891 # For backwards compatibility
2902 2892 runcode = run_code
2903 2893
2904 2894 #-------------------------------------------------------------------------
2905 2895 # Things related to GUI support and pylab
2906 2896 #-------------------------------------------------------------------------
2907 2897
2908 2898 def enable_gui(self, gui=None):
2909 2899 raise NotImplementedError('Implement enable_gui in a subclass')
2910 2900
2911 2901 def enable_matplotlib(self, gui=None):
2912 2902 """Enable interactive matplotlib and inline figure support.
2913 2903
2914 2904 This takes the following steps:
2915 2905
2916 2906 1. select the appropriate eventloop and matplotlib backend
2917 2907 2. set up matplotlib for interactive use with that backend
2918 2908 3. configure formatters for inline figure display
2919 2909 4. enable the selected gui eventloop
2920 2910
2921 2911 Parameters
2922 2912 ----------
2923 2913 gui : optional, string
2924 2914 If given, dictates the choice of matplotlib GUI backend to use
2925 2915 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2926 2916 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2927 2917 matplotlib (as dictated by the matplotlib build-time options plus the
2928 2918 user's matplotlibrc configuration file). Note that not all backends
2929 2919 make sense in all contexts, for example a terminal ipython can't
2930 2920 display figures inline.
2931 2921 """
2932 2922 from IPython.core import pylabtools as pt
2933 2923 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
2934 2924
2935 2925 if gui != 'inline':
2936 2926 # If we have our first gui selection, store it
2937 2927 if self.pylab_gui_select is None:
2938 2928 self.pylab_gui_select = gui
2939 2929 # Otherwise if they are different
2940 2930 elif gui != self.pylab_gui_select:
2941 2931 print ('Warning: Cannot change to a different GUI toolkit: %s.'
2942 2932 ' Using %s instead.' % (gui, self.pylab_gui_select))
2943 2933 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
2944 2934
2945 2935 pt.activate_matplotlib(backend)
2946 2936 pt.configure_inline_support(self, backend)
2947 2937
2948 2938 # Now we must activate the gui pylab wants to use, and fix %run to take
2949 2939 # plot updates into account
2950 2940 self.enable_gui(gui)
2951 2941 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2952 2942 pt.mpl_runner(self.safe_execfile)
2953 2943
2954 2944 return gui, backend
2955 2945
2956 2946 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
2957 2947 """Activate pylab support at runtime.
2958 2948
2959 2949 This turns on support for matplotlib, preloads into the interactive
2960 2950 namespace all of numpy and pylab, and configures IPython to correctly
2961 2951 interact with the GUI event loop. The GUI backend to be used can be
2962 2952 optionally selected with the optional ``gui`` argument.
2963 2953
2964 2954 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
2965 2955
2966 2956 Parameters
2967 2957 ----------
2968 2958 gui : optional, string
2969 2959 If given, dictates the choice of matplotlib GUI backend to use
2970 2960 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2971 2961 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2972 2962 matplotlib (as dictated by the matplotlib build-time options plus the
2973 2963 user's matplotlibrc configuration file). Note that not all backends
2974 2964 make sense in all contexts, for example a terminal ipython can't
2975 2965 display figures inline.
2976 2966 import_all : optional, bool, default: True
2977 2967 Whether to do `from numpy import *` and `from pylab import *`
2978 2968 in addition to module imports.
2979 2969 welcome_message : deprecated
2980 2970 This argument is ignored, no welcome message will be displayed.
2981 2971 """
2982 2972 from IPython.core.pylabtools import import_pylab
2983 2973
2984 2974 gui, backend = self.enable_matplotlib(gui)
2985 2975
2986 2976 # We want to prevent the loading of pylab to pollute the user's
2987 2977 # namespace as shown by the %who* magics, so we execute the activation
2988 2978 # code in an empty namespace, and we update *both* user_ns and
2989 2979 # user_ns_hidden with this information.
2990 2980 ns = {}
2991 2981 import_pylab(ns, import_all)
2992 2982 # warn about clobbered names
2993 2983 ignored = {"__builtins__"}
2994 2984 both = set(ns).intersection(self.user_ns).difference(ignored)
2995 2985 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
2996 2986 self.user_ns.update(ns)
2997 2987 self.user_ns_hidden.update(ns)
2998 2988 return gui, backend, clobbered
2999 2989
3000 2990 #-------------------------------------------------------------------------
3001 2991 # Utilities
3002 2992 #-------------------------------------------------------------------------
3003 2993
3004 2994 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
3005 2995 """Expand python variables in a string.
3006 2996
3007 2997 The depth argument indicates how many frames above the caller should
3008 2998 be walked to look for the local namespace where to expand variables.
3009 2999
3010 3000 The global namespace for expansion is always the user's interactive
3011 3001 namespace.
3012 3002 """
3013 3003 ns = self.user_ns.copy()
3014 3004 try:
3015 3005 frame = sys._getframe(depth+1)
3016 3006 except ValueError:
3017 3007 # This is thrown if there aren't that many frames on the stack,
3018 3008 # e.g. if a script called run_line_magic() directly.
3019 3009 pass
3020 3010 else:
3021 3011 ns.update(frame.f_locals)
3022 3012
3023 3013 try:
3024 3014 # We have to use .vformat() here, because 'self' is a valid and common
3025 3015 # name, and expanding **ns for .format() would make it collide with
3026 3016 # the 'self' argument of the method.
3027 3017 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
3028 3018 except Exception:
3029 3019 # if formatter couldn't format, just let it go untransformed
3030 3020 pass
3031 3021 return cmd
3032 3022
3033 3023 def mktempfile(self, data=None, prefix='ipython_edit_'):
3034 3024 """Make a new tempfile and return its filename.
3035 3025
3036 3026 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3037 3027 but it registers the created filename internally so ipython cleans it up
3038 3028 at exit time.
3039 3029
3040 3030 Optional inputs:
3041 3031
3042 3032 - data(None): if data is given, it gets written out to the temp file
3043 3033 immediately, and the file is closed again."""
3044 3034
3045 3035 dirname = tempfile.mkdtemp(prefix=prefix)
3046 3036 self.tempdirs.append(dirname)
3047 3037
3048 3038 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3049 3039 os.close(handle) # On Windows, there can only be one open handle on a file
3050 3040 self.tempfiles.append(filename)
3051 3041
3052 3042 if data:
3053 3043 tmp_file = open(filename,'w')
3054 3044 tmp_file.write(data)
3055 3045 tmp_file.close()
3056 3046 return filename
3057 3047
3058 3048 @undoc
3059 3049 def write(self,data):
3060 3050 """DEPRECATED: Write a string to the default output"""
3061 3051 warn('InteractiveShell.write() is deprecated, use sys.stdout instead',
3062 3052 DeprecationWarning, stacklevel=2)
3063 3053 sys.stdout.write(data)
3064 3054
3065 3055 @undoc
3066 3056 def write_err(self,data):
3067 3057 """DEPRECATED: Write a string to the default error output"""
3068 3058 warn('InteractiveShell.write_err() is deprecated, use sys.stderr instead',
3069 3059 DeprecationWarning, stacklevel=2)
3070 3060 sys.stderr.write(data)
3071 3061
3072 3062 def ask_yes_no(self, prompt, default=None, interrupt=None):
3073 3063 if self.quiet:
3074 3064 return True
3075 3065 return ask_yes_no(prompt,default,interrupt)
3076 3066
3077 3067 def show_usage(self):
3078 3068 """Show a usage message"""
3079 3069 page.page(IPython.core.usage.interactive_usage)
3080 3070
3081 3071 def extract_input_lines(self, range_str, raw=False):
3082 3072 """Return as a string a set of input history slices.
3083 3073
3084 3074 Parameters
3085 3075 ----------
3086 3076 range_str : string
3087 3077 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3088 3078 since this function is for use by magic functions which get their
3089 3079 arguments as strings. The number before the / is the session
3090 3080 number: ~n goes n back from the current session.
3091 3081
3092 3082 raw : bool, optional
3093 3083 By default, the processed input is used. If this is true, the raw
3094 3084 input history is used instead.
3095 3085
3096 3086 Notes
3097 3087 -----
3098 3088
3099 3089 Slices can be described with two notations:
3100 3090
3101 3091 * ``N:M`` -> standard python form, means including items N...(M-1).
3102 3092 * ``N-M`` -> include items N..M (closed endpoint).
3103 3093 """
3104 3094 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3105 3095 return "\n".join(x for _, _, x in lines)
3106 3096
3107 3097 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3108 3098 """Get a code string from history, file, url, or a string or macro.
3109 3099
3110 3100 This is mainly used by magic functions.
3111 3101
3112 3102 Parameters
3113 3103 ----------
3114 3104
3115 3105 target : str
3116 3106
3117 3107 A string specifying code to retrieve. This will be tried respectively
3118 3108 as: ranges of input history (see %history for syntax), url,
3119 3109 corresponding .py file, filename, or an expression evaluating to a
3120 3110 string or Macro in the user namespace.
3121 3111
3122 3112 raw : bool
3123 3113 If true (default), retrieve raw history. Has no effect on the other
3124 3114 retrieval mechanisms.
3125 3115
3126 3116 py_only : bool (default False)
3127 3117 Only try to fetch python code, do not try alternative methods to decode file
3128 3118 if unicode fails.
3129 3119
3130 3120 Returns
3131 3121 -------
3132 3122 A string of code.
3133 3123
3134 3124 ValueError is raised if nothing is found, and TypeError if it evaluates
3135 3125 to an object of another type. In each case, .args[0] is a printable
3136 3126 message.
3137 3127 """
3138 3128 code = self.extract_input_lines(target, raw=raw) # Grab history
3139 3129 if code:
3140 3130 return code
3141 3131 utarget = unquote_filename(target)
3142 3132 try:
3143 3133 if utarget.startswith(('http://', 'https://')):
3144 3134 return openpy.read_py_url(utarget, skip_encoding_cookie=skip_encoding_cookie)
3145 3135 except UnicodeDecodeError:
3146 3136 if not py_only :
3147 3137 # Deferred import
3148 3138 try:
3149 3139 from urllib.request import urlopen # Py3
3150 3140 except ImportError:
3151 3141 from urllib import urlopen
3152 3142 response = urlopen(target)
3153 3143 return response.read().decode('latin1')
3154 3144 raise ValueError(("'%s' seem to be unreadable.") % utarget)
3155 3145
3156 3146 potential_target = [target]
3157 3147 try :
3158 3148 potential_target.insert(0,get_py_filename(target))
3159 3149 except IOError:
3160 3150 pass
3161 3151
3162 3152 for tgt in potential_target :
3163 3153 if os.path.isfile(tgt): # Read file
3164 3154 try :
3165 3155 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3166 3156 except UnicodeDecodeError :
3167 3157 if not py_only :
3168 3158 with io_open(tgt,'r', encoding='latin1') as f :
3169 3159 return f.read()
3170 3160 raise ValueError(("'%s' seem to be unreadable.") % target)
3171 3161 elif os.path.isdir(os.path.expanduser(tgt)):
3172 3162 raise ValueError("'%s' is a directory, not a regular file." % target)
3173 3163
3174 3164 if search_ns:
3175 3165 # Inspect namespace to load object source
3176 3166 object_info = self.object_inspect(target, detail_level=1)
3177 3167 if object_info['found'] and object_info['source']:
3178 3168 return object_info['source']
3179 3169
3180 3170 try: # User namespace
3181 3171 codeobj = eval(target, self.user_ns)
3182 3172 except Exception:
3183 3173 raise ValueError(("'%s' was not found in history, as a file, url, "
3184 3174 "nor in the user namespace.") % target)
3185 3175
3186 3176 if isinstance(codeobj, string_types):
3187 3177 return codeobj
3188 3178 elif isinstance(codeobj, Macro):
3189 3179 return codeobj.value
3190 3180
3191 3181 raise TypeError("%s is neither a string nor a macro." % target,
3192 3182 codeobj)
3193 3183
3194 3184 #-------------------------------------------------------------------------
3195 3185 # Things related to IPython exiting
3196 3186 #-------------------------------------------------------------------------
3197 3187 def atexit_operations(self):
3198 3188 """This will be executed at the time of exit.
3199 3189
3200 3190 Cleanup operations and saving of persistent data that is done
3201 3191 unconditionally by IPython should be performed here.
3202 3192
3203 3193 For things that may depend on startup flags or platform specifics (such
3204 3194 as having readline or not), register a separate atexit function in the
3205 3195 code that has the appropriate information, rather than trying to
3206 3196 clutter
3207 3197 """
3208 3198 # Close the history session (this stores the end time and line count)
3209 3199 # this must be *before* the tempfile cleanup, in case of temporary
3210 3200 # history db
3211 3201 self.history_manager.end_session()
3212 3202
3213 3203 # Cleanup all tempfiles and folders left around
3214 3204 for tfile in self.tempfiles:
3215 3205 try:
3216 3206 os.unlink(tfile)
3217 3207 except OSError:
3218 3208 pass
3219 3209
3220 3210 for tdir in self.tempdirs:
3221 3211 try:
3222 3212 os.rmdir(tdir)
3223 3213 except OSError:
3224 3214 pass
3225 3215
3226 3216 # Clear all user namespaces to release all references cleanly.
3227 3217 self.reset(new_session=False)
3228 3218
3229 3219 # Run user hooks
3230 3220 self.hooks.shutdown_hook()
3231 3221
3232 3222 def cleanup(self):
3233 3223 self.restore_sys_module_state()
3234 3224
3235 3225
3226 # Overridden in terminal subclass to change prompts
3227 def switch_doctest_mode(self, mode):
3228 pass
3229
3230
3236 3231 class InteractiveShellABC(with_metaclass(abc.ABCMeta, object)):
3237 3232 """An abstract base class for InteractiveShell."""
3238 3233
3239 3234 InteractiveShellABC.register(InteractiveShell)
@@ -1,614 +1,599 b''
1 1 """Implementation of basic magic functions."""
2 2
3 3 from __future__ import print_function
4 4 from __future__ import absolute_import
5 5
6 6 import io
7 7 import sys
8 8 from pprint import pformat
9 9
10 10 from IPython.core import magic_arguments, page
11 11 from IPython.core.error import UsageError
12 12 from IPython.core.magic import Magics, magics_class, line_magic, magic_escapes
13 13 from IPython.utils.text import format_screen, dedent, indent
14 14 from IPython.testing.skipdoctest import skip_doctest
15 15 from IPython.utils.ipstruct import Struct
16 16 from IPython.utils.path import unquote_filename
17 17 from IPython.utils.py3compat import unicode_type
18 18 from warnings import warn
19 19 from logging import error
20 20
21 21
22 22 class MagicsDisplay(object):
23 23 def __init__(self, magics_manager):
24 24 self.magics_manager = magics_manager
25 25
26 26 def _lsmagic(self):
27 27 """The main implementation of the %lsmagic"""
28 28 mesc = magic_escapes['line']
29 29 cesc = magic_escapes['cell']
30 30 mman = self.magics_manager
31 31 magics = mman.lsmagic()
32 32 out = ['Available line magics:',
33 33 mesc + (' '+mesc).join(sorted(magics['line'])),
34 34 '',
35 35 'Available cell magics:',
36 36 cesc + (' '+cesc).join(sorted(magics['cell'])),
37 37 '',
38 38 mman.auto_status()]
39 39 return '\n'.join(out)
40 40
41 41 def _repr_pretty_(self, p, cycle):
42 42 p.text(self._lsmagic())
43 43
44 44 def __str__(self):
45 45 return self._lsmagic()
46 46
47 47 def _jsonable(self):
48 48 """turn magics dict into jsonable dict of the same structure
49 49
50 50 replaces object instances with their class names as strings
51 51 """
52 52 magic_dict = {}
53 53 mman = self.magics_manager
54 54 magics = mman.lsmagic()
55 55 for key, subdict in magics.items():
56 56 d = {}
57 57 magic_dict[key] = d
58 58 for name, obj in subdict.items():
59 59 try:
60 60 classname = obj.__self__.__class__.__name__
61 61 except AttributeError:
62 62 classname = 'Other'
63 63
64 64 d[name] = classname
65 65 return magic_dict
66 66
67 67 def _repr_json_(self):
68 68 return self._jsonable()
69 69
70 70
71 71 @magics_class
72 72 class BasicMagics(Magics):
73 73 """Magics that provide central IPython functionality.
74 74
75 75 These are various magics that don't fit into specific categories but that
76 76 are all part of the base 'IPython experience'."""
77 77
78 78 @magic_arguments.magic_arguments()
79 79 @magic_arguments.argument(
80 80 '-l', '--line', action='store_true',
81 81 help="""Create a line magic alias."""
82 82 )
83 83 @magic_arguments.argument(
84 84 '-c', '--cell', action='store_true',
85 85 help="""Create a cell magic alias."""
86 86 )
87 87 @magic_arguments.argument(
88 88 'name',
89 89 help="""Name of the magic to be created."""
90 90 )
91 91 @magic_arguments.argument(
92 92 'target',
93 93 help="""Name of the existing line or cell magic."""
94 94 )
95 95 @line_magic
96 96 def alias_magic(self, line=''):
97 97 """Create an alias for an existing line or cell magic.
98 98
99 99 Examples
100 100 --------
101 101 ::
102 102
103 103 In [1]: %alias_magic t timeit
104 104 Created `%t` as an alias for `%timeit`.
105 105 Created `%%t` as an alias for `%%timeit`.
106 106
107 107 In [2]: %t -n1 pass
108 108 1 loops, best of 3: 954 ns per loop
109 109
110 110 In [3]: %%t -n1
111 111 ...: pass
112 112 ...:
113 113 1 loops, best of 3: 954 ns per loop
114 114
115 115 In [4]: %alias_magic --cell whereami pwd
116 116 UsageError: Cell magic function `%%pwd` not found.
117 117 In [5]: %alias_magic --line whereami pwd
118 118 Created `%whereami` as an alias for `%pwd`.
119 119
120 120 In [6]: %whereami
121 121 Out[6]: u'/home/testuser'
122 122 """
123 123 args = magic_arguments.parse_argstring(self.alias_magic, line)
124 124 shell = self.shell
125 125 mman = self.shell.magics_manager
126 126 escs = ''.join(magic_escapes.values())
127 127
128 128 target = args.target.lstrip(escs)
129 129 name = args.name.lstrip(escs)
130 130
131 131 # Find the requested magics.
132 132 m_line = shell.find_magic(target, 'line')
133 133 m_cell = shell.find_magic(target, 'cell')
134 134 if args.line and m_line is None:
135 135 raise UsageError('Line magic function `%s%s` not found.' %
136 136 (magic_escapes['line'], target))
137 137 if args.cell and m_cell is None:
138 138 raise UsageError('Cell magic function `%s%s` not found.' %
139 139 (magic_escapes['cell'], target))
140 140
141 141 # If --line and --cell are not specified, default to the ones
142 142 # that are available.
143 143 if not args.line and not args.cell:
144 144 if not m_line and not m_cell:
145 145 raise UsageError(
146 146 'No line or cell magic with name `%s` found.' % target
147 147 )
148 148 args.line = bool(m_line)
149 149 args.cell = bool(m_cell)
150 150
151 151 if args.line:
152 152 mman.register_alias(name, target, 'line')
153 153 print('Created `%s%s` as an alias for `%s%s`.' % (
154 154 magic_escapes['line'], name,
155 155 magic_escapes['line'], target))
156 156
157 157 if args.cell:
158 158 mman.register_alias(name, target, 'cell')
159 159 print('Created `%s%s` as an alias for `%s%s`.' % (
160 160 magic_escapes['cell'], name,
161 161 magic_escapes['cell'], target))
162 162
163 163 @line_magic
164 164 def lsmagic(self, parameter_s=''):
165 165 """List currently available magic functions."""
166 166 return MagicsDisplay(self.shell.magics_manager)
167 167
168 168 def _magic_docs(self, brief=False, rest=False):
169 169 """Return docstrings from magic functions."""
170 170 mman = self.shell.magics_manager
171 171 docs = mman.lsmagic_docs(brief, missing='No documentation')
172 172
173 173 if rest:
174 174 format_string = '**%s%s**::\n\n%s\n\n'
175 175 else:
176 176 format_string = '%s%s:\n%s\n'
177 177
178 178 return ''.join(
179 179 [format_string % (magic_escapes['line'], fname,
180 180 indent(dedent(fndoc)))
181 181 for fname, fndoc in sorted(docs['line'].items())]
182 182 +
183 183 [format_string % (magic_escapes['cell'], fname,
184 184 indent(dedent(fndoc)))
185 185 for fname, fndoc in sorted(docs['cell'].items())]
186 186 )
187 187
188 188 @line_magic
189 189 def magic(self, parameter_s=''):
190 190 """Print information about the magic function system.
191 191
192 192 Supported formats: -latex, -brief, -rest
193 193 """
194 194
195 195 mode = ''
196 196 try:
197 197 mode = parameter_s.split()[0][1:]
198 198 except IndexError:
199 199 pass
200 200
201 201 brief = (mode == 'brief')
202 202 rest = (mode == 'rest')
203 203 magic_docs = self._magic_docs(brief, rest)
204 204
205 205 if mode == 'latex':
206 206 print(self.format_latex(magic_docs))
207 207 return
208 208 else:
209 209 magic_docs = format_screen(magic_docs)
210 210
211 211 out = ["""
212 212 IPython's 'magic' functions
213 213 ===========================
214 214
215 215 The magic function system provides a series of functions which allow you to
216 216 control the behavior of IPython itself, plus a lot of system-type
217 217 features. There are two kinds of magics, line-oriented and cell-oriented.
218 218
219 219 Line magics are prefixed with the % character and work much like OS
220 220 command-line calls: they get as an argument the rest of the line, where
221 221 arguments are passed without parentheses or quotes. For example, this will
222 222 time the given statement::
223 223
224 224 %timeit range(1000)
225 225
226 226 Cell magics are prefixed with a double %%, and they are functions that get as
227 227 an argument not only the rest of the line, but also the lines below it in a
228 228 separate argument. These magics are called with two arguments: the rest of the
229 229 call line and the body of the cell, consisting of the lines below the first.
230 230 For example::
231 231
232 232 %%timeit x = numpy.random.randn((100, 100))
233 233 numpy.linalg.svd(x)
234 234
235 235 will time the execution of the numpy svd routine, running the assignment of x
236 236 as part of the setup phase, which is not timed.
237 237
238 238 In a line-oriented client (the terminal or Qt console IPython), starting a new
239 239 input with %% will automatically enter cell mode, and IPython will continue
240 240 reading input until a blank line is given. In the notebook, simply type the
241 241 whole cell as one entity, but keep in mind that the %% escape can only be at
242 242 the very start of the cell.
243 243
244 244 NOTE: If you have 'automagic' enabled (via the command line option or with the
245 245 %automagic function), you don't need to type in the % explicitly for line
246 246 magics; cell magics always require an explicit '%%' escape. By default,
247 247 IPython ships with automagic on, so you should only rarely need the % escape.
248 248
249 249 Example: typing '%cd mydir' (without the quotes) changes your working directory
250 250 to 'mydir', if it exists.
251 251
252 252 For a list of the available magic functions, use %lsmagic. For a description
253 253 of any of them, type %magic_name?, e.g. '%cd?'.
254 254
255 255 Currently the magic system has the following functions:""",
256 256 magic_docs,
257 257 "Summary of magic functions (from %slsmagic):" % magic_escapes['line'],
258 258 str(self.lsmagic()),
259 259 ]
260 260 page.page('\n'.join(out))
261 261
262 262
263 263 @line_magic
264 264 def page(self, parameter_s=''):
265 265 """Pretty print the object and display it through a pager.
266 266
267 267 %page [options] OBJECT
268 268
269 269 If no object is given, use _ (last output).
270 270
271 271 Options:
272 272
273 273 -r: page str(object), don't pretty-print it."""
274 274
275 275 # After a function contributed by Olivier Aubert, slightly modified.
276 276
277 277 # Process options/args
278 278 opts, args = self.parse_options(parameter_s, 'r')
279 279 raw = 'r' in opts
280 280
281 281 oname = args and args or '_'
282 282 info = self.shell._ofind(oname)
283 283 if info['found']:
284 284 txt = (raw and str or pformat)( info['obj'] )
285 285 page.page(txt)
286 286 else:
287 287 print('Object `%s` not found' % oname)
288 288
289 289 @line_magic
290 290 def profile(self, parameter_s=''):
291 291 """Print your currently active IPython profile.
292 292
293 293 See Also
294 294 --------
295 295 prun : run code using the Python profiler
296 296 (:meth:`~IPython.core.magics.execution.ExecutionMagics.prun`)
297 297 """
298 298 warn("%profile is now deprecated. Please use get_ipython().profile instead.")
299 299 from IPython.core.application import BaseIPythonApplication
300 300 if BaseIPythonApplication.initialized():
301 301 print(BaseIPythonApplication.instance().profile)
302 302 else:
303 303 error("profile is an application-level value, but you don't appear to be in an IPython application")
304 304
305 305 @line_magic
306 306 def pprint(self, parameter_s=''):
307 307 """Toggle pretty printing on/off."""
308 308 ptformatter = self.shell.display_formatter.formatters['text/plain']
309 309 ptformatter.pprint = bool(1 - ptformatter.pprint)
310 310 print('Pretty printing has been turned',
311 311 ['OFF','ON'][ptformatter.pprint])
312 312
313 313 @line_magic
314 314 def colors(self, parameter_s=''):
315 315 """Switch color scheme for prompts, info system and exception handlers.
316 316
317 317 Currently implemented schemes: NoColor, Linux, LightBG.
318 318
319 319 Color scheme names are not case-sensitive.
320 320
321 321 Examples
322 322 --------
323 323 To get a plain black and white terminal::
324 324
325 325 %colors nocolor
326 326 """
327 327 def color_switch_err(name):
328 328 warn('Error changing %s color schemes.\n%s' %
329 329 (name, sys.exc_info()[1]))
330 330
331 331
332 332 new_scheme = parameter_s.strip()
333 333 if not new_scheme:
334 334 raise UsageError(
335 335 "%colors: you must specify a color scheme. See '%colors?'")
336 336 # local shortcut
337 337 shell = self.shell
338 338
339 339
340 340
341 341 if not shell.colors_force:
342 342 if sys.platform in {'win32', 'cli'}:
343 343 import IPython.utils.rlineimpl as readline
344 344 if not readline.have_readline:
345 345 msg = """\
346 346 Proper color support under MS Windows requires the pyreadline library.
347 347 You can find it at:
348 348 http://ipython.org/pyreadline.html
349 349
350 350 Defaulting color scheme to 'NoColor'"""
351 351 new_scheme = 'NoColor'
352 352 warn(msg)
353 353
354 354 elif not shell.has_readline:
355 355 # Coloured prompts get messed up without readline
356 356 # Will remove this check after switching to prompt_toolkit
357 357 new_scheme = 'NoColor'
358 358
359 # Set prompt colors
360 try:
361 shell.prompt_manager.color_scheme = new_scheme
362 except:
363 color_switch_err('prompt')
364 else:
365 shell.colors = \
366 shell.prompt_manager.color_scheme_table.active_scheme_name
367 359 # Set exception colors
368 360 try:
369 361 shell.InteractiveTB.set_colors(scheme = new_scheme)
370 362 shell.SyntaxTB.set_colors(scheme = new_scheme)
371 363 except:
372 364 color_switch_err('exception')
373 365
374 366 # Set info (for 'object?') colors
375 367 if shell.color_info:
376 368 try:
377 369 shell.inspector.set_active_scheme(new_scheme)
378 370 except:
379 371 color_switch_err('object inspector')
380 372 else:
381 373 shell.inspector.set_active_scheme('NoColor')
382 374
383 375 @line_magic
384 376 def xmode(self, parameter_s=''):
385 377 """Switch modes for the exception handlers.
386 378
387 379 Valid modes: Plain, Context and Verbose.
388 380
389 381 If called without arguments, acts as a toggle."""
390 382
391 383 def xmode_switch_err(name):
392 384 warn('Error changing %s exception modes.\n%s' %
393 385 (name,sys.exc_info()[1]))
394 386
395 387 shell = self.shell
396 388 new_mode = parameter_s.strip().capitalize()
397 389 try:
398 390 shell.InteractiveTB.set_mode(mode=new_mode)
399 391 print('Exception reporting mode:',shell.InteractiveTB.mode)
400 392 except:
401 393 xmode_switch_err('user')
402 394
403 395 @line_magic
404 396 def quickref(self,arg):
405 397 """ Show a quick reference sheet """
406 398 from IPython.core.usage import quick_reference
407 399 qr = quick_reference + self._magic_docs(brief=True)
408 400 page.page(qr)
409 401
410 402 @line_magic
411 403 def doctest_mode(self, parameter_s=''):
412 404 """Toggle doctest mode on and off.
413 405
414 406 This mode is intended to make IPython behave as much as possible like a
415 407 plain Python shell, from the perspective of how its prompts, exceptions
416 408 and output look. This makes it easy to copy and paste parts of a
417 409 session into doctests. It does so by:
418 410
419 411 - Changing the prompts to the classic ``>>>`` ones.
420 412 - Changing the exception reporting mode to 'Plain'.
421 413 - Disabling pretty-printing of output.
422 414
423 415 Note that IPython also supports the pasting of code snippets that have
424 416 leading '>>>' and '...' prompts in them. This means that you can paste
425 417 doctests from files or docstrings (even if they have leading
426 418 whitespace), and the code will execute correctly. You can then use
427 419 '%history -t' to see the translated history; this will give you the
428 420 input after removal of all the leading prompts and whitespace, which
429 421 can be pasted back into an editor.
430 422
431 423 With these features, you can switch into this mode easily whenever you
432 424 need to do testing and changes to doctests, without having to leave
433 425 your existing IPython session.
434 426 """
435 427
436 428 # Shorthands
437 429 shell = self.shell
438 pm = shell.prompt_manager
439 430 meta = shell.meta
440 431 disp_formatter = self.shell.display_formatter
441 432 ptformatter = disp_formatter.formatters['text/plain']
442 433 # dstore is a data store kept in the instance metadata bag to track any
443 434 # changes we make, so we can undo them later.
444 435 dstore = meta.setdefault('doctest_mode',Struct())
445 436 save_dstore = dstore.setdefault
446 437
447 438 # save a few values we'll need to recover later
448 439 mode = save_dstore('mode',False)
449 440 save_dstore('rc_pprint',ptformatter.pprint)
450 441 save_dstore('xmode',shell.InteractiveTB.mode)
451 442 save_dstore('rc_separate_out',shell.separate_out)
452 443 save_dstore('rc_separate_out2',shell.separate_out2)
453 save_dstore('rc_prompts_pad_left',pm.justify)
454 444 save_dstore('rc_separate_in',shell.separate_in)
455 445 save_dstore('rc_active_types',disp_formatter.active_types)
456 save_dstore('prompt_templates',(pm.in_template, pm.in2_template, pm.out_template))
457 446
458 447 if not mode:
459 448 # turn on
460 pm.in_template = '>>> '
461 pm.in2_template = '... '
462 pm.out_template = ''
463 449
464 450 # Prompt separators like plain python
465 451 shell.separate_in = ''
466 452 shell.separate_out = ''
467 453 shell.separate_out2 = ''
468 454
469 pm.justify = False
470 455
471 456 ptformatter.pprint = False
472 457 disp_formatter.active_types = ['text/plain']
473 458
474 459 shell.magic('xmode Plain')
475 460 else:
476 461 # turn off
477 pm.in_template, pm.in2_template, pm.out_template = dstore.prompt_templates
478
479 462 shell.separate_in = dstore.rc_separate_in
480 463
481 464 shell.separate_out = dstore.rc_separate_out
482 465 shell.separate_out2 = dstore.rc_separate_out2
483 466
484 pm.justify = dstore.rc_prompts_pad_left
485
486 467 ptformatter.pprint = dstore.rc_pprint
487 468 disp_formatter.active_types = dstore.rc_active_types
488 469
489 470 shell.magic('xmode ' + dstore.xmode)
490 471
472 # mode here is the state before we switch; switch_doctest_mode takes
473 # the mode we're switching to.
474 shell.switch_doctest_mode(not mode)
475
491 476 # Store new mode and inform
492 dstore.mode = bool(1-int(mode))
477 dstore.mode = bool(not mode)
493 478 mode_label = ['OFF','ON'][dstore.mode]
494 479 print('Doctest mode is:', mode_label)
495 480
496 481 @line_magic
497 482 def gui(self, parameter_s=''):
498 483 """Enable or disable IPython GUI event loop integration.
499 484
500 485 %gui [GUINAME]
501 486
502 487 This magic replaces IPython's threaded shells that were activated
503 488 using the (pylab/wthread/etc.) command line flags. GUI toolkits
504 489 can now be enabled at runtime and keyboard
505 490 interrupts should work without any problems. The following toolkits
506 491 are supported: wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::
507 492
508 493 %gui wx # enable wxPython event loop integration
509 494 %gui qt4|qt # enable PyQt4 event loop integration
510 495 %gui qt5 # enable PyQt5 event loop integration
511 496 %gui gtk # enable PyGTK event loop integration
512 497 %gui gtk3 # enable Gtk3 event loop integration
513 498 %gui tk # enable Tk event loop integration
514 499 %gui osx # enable Cocoa event loop integration
515 500 # (requires %matplotlib 1.1)
516 501 %gui # disable all event loop integration
517 502
518 503 WARNING: after any of these has been called you can simply create
519 504 an application object, but DO NOT start the event loop yourself, as
520 505 we have already handled that.
521 506 """
522 507 opts, arg = self.parse_options(parameter_s, '')
523 508 if arg=='': arg = None
524 509 try:
525 510 return self.shell.enable_gui(arg)
526 511 except Exception as e:
527 512 # print simple error message, rather than traceback if we can't
528 513 # hook up the GUI
529 514 error(str(e))
530 515
531 516 @skip_doctest
532 517 @line_magic
533 518 def precision(self, s=''):
534 519 """Set floating point precision for pretty printing.
535 520
536 521 Can set either integer precision or a format string.
537 522
538 523 If numpy has been imported and precision is an int,
539 524 numpy display precision will also be set, via ``numpy.set_printoptions``.
540 525
541 526 If no argument is given, defaults will be restored.
542 527
543 528 Examples
544 529 --------
545 530 ::
546 531
547 532 In [1]: from math import pi
548 533
549 534 In [2]: %precision 3
550 535 Out[2]: u'%.3f'
551 536
552 537 In [3]: pi
553 538 Out[3]: 3.142
554 539
555 540 In [4]: %precision %i
556 541 Out[4]: u'%i'
557 542
558 543 In [5]: pi
559 544 Out[5]: 3
560 545
561 546 In [6]: %precision %e
562 547 Out[6]: u'%e'
563 548
564 549 In [7]: pi**10
565 550 Out[7]: 9.364805e+04
566 551
567 552 In [8]: %precision
568 553 Out[8]: u'%r'
569 554
570 555 In [9]: pi**10
571 556 Out[9]: 93648.047476082982
572 557 """
573 558 ptformatter = self.shell.display_formatter.formatters['text/plain']
574 559 ptformatter.float_precision = s
575 560 return ptformatter.float_format
576 561
577 562 @magic_arguments.magic_arguments()
578 563 @magic_arguments.argument(
579 564 '-e', '--export', action='store_true', default=False,
580 565 help='Export IPython history as a notebook. The filename argument '
581 566 'is used to specify the notebook name and format. For example '
582 567 'a filename of notebook.ipynb will result in a notebook name '
583 568 'of "notebook" and a format of "json". Likewise using a ".py" '
584 569 'file extension will write the notebook as a Python script'
585 570 )
586 571 @magic_arguments.argument(
587 572 'filename', type=unicode_type,
588 573 help='Notebook name or filename'
589 574 )
590 575 @line_magic
591 576 def notebook(self, s):
592 577 """Export and convert IPython notebooks.
593 578
594 579 This function can export the current IPython history to a notebook file.
595 580 For example, to export the history to "foo.ipynb" do "%notebook -e foo.ipynb".
596 581 To export the history to "foo.py" do "%notebook -e foo.py".
597 582 """
598 583 args = magic_arguments.parse_argstring(self.notebook, s)
599 584
600 585 from nbformat import write, v4
601 586 args.filename = unquote_filename(args.filename)
602 587 if args.export:
603 588 cells = []
604 589 hist = list(self.shell.history_manager.get_range())
605 590 if(len(hist)<=1):
606 591 raise ValueError('History is empty, cannot export')
607 592 for session, execution_count, source in hist[:-1]:
608 593 cells.append(v4.new_code_cell(
609 594 execution_count=execution_count,
610 595 source=source
611 596 ))
612 597 nb = v4.new_notebook(cells=cells)
613 598 with io.open(args.filename, 'w', encoding='utf-8') as f:
614 599 write(nb, f, version=4)
@@ -1,412 +1,26 b''
1 1 # -*- coding: utf-8 -*-
2 """Classes for handling input/output prompts."""
2 """Being removed
3 """
3 4
4 # Copyright (c) 2001-2007 Fernando Perez <fperez@colorado.edu>
5 # Copyright (c) IPython Development Team.
6 # Distributed under the terms of the Modified BSD License.
7
8 import os
9 import re
10 import socket
11 import sys
12 import time
13
14 from string import Formatter
15
16 from traitlets.config.configurable import Configurable
17 from IPython.core import release
18 from IPython.utils import coloransi, py3compat
19 from traitlets import Unicode, Instance, Dict, Bool, Int, observe, default
20
21 from IPython.utils.PyColorize import LightBGColors, LinuxColors, NoColor
22
23 #-----------------------------------------------------------------------------
24 # Color schemes for prompts
25 #-----------------------------------------------------------------------------
26
27 InputColors = coloransi.InputTermColors # just a shorthand
28 Colors = coloransi.TermColors # just a shorthand
29
30 color_lists = dict(normal=Colors(), inp=InputColors(), nocolor=coloransi.NoColors())
31
32 #-----------------------------------------------------------------------------
33 # Utilities
34 #-----------------------------------------------------------------------------
5 from IPython.utils import py3compat
35 6
36 7 class LazyEvaluate(object):
37 8 """This is used for formatting strings with values that need to be updated
38 9 at that time, such as the current time or working directory."""
39 10 def __init__(self, func, *args, **kwargs):
40 11 self.func = func
41 12 self.args = args
42 13 self.kwargs = kwargs
43 14
44 15 def __call__(self, **kwargs):
45 16 self.kwargs.update(kwargs)
46 17 return self.func(*self.args, **self.kwargs)
47 18
48 19 def __str__(self):
49 20 return str(self())
50 21
51 22 def __unicode__(self):
52 23 return py3compat.unicode_type(self())
53 24
54 25 def __format__(self, format_spec):
55 26 return format(self(), format_spec)
56
57 def multiple_replace(dict, text):
58 """ Replace in 'text' all occurrences of any key in the given
59 dictionary by its corresponding value. Returns the new string."""
60
61 # Function by Xavier Defrang, originally found at:
62 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
63
64 # Create a regular expression from the dictionary keys
65 regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
66 # For each match, look-up corresponding value in dictionary
67 return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
68
69 #-----------------------------------------------------------------------------
70 # Special characters that can be used in prompt templates, mainly bash-like
71 #-----------------------------------------------------------------------------
72
73 # If $HOME isn't defined (Windows), make it an absurd string so that it can
74 # never be expanded out into '~'. Basically anything which can never be a
75 # reasonable directory name will do, we just want the $HOME -> '~' operation
76 # to become a no-op. We pre-compute $HOME here so it's not done on every
77 # prompt call.
78
79 # FIXME:
80
81 # - This should be turned into a class which does proper namespace management,
82 # since the prompt specials need to be evaluated in a certain namespace.
83 # Currently it's just globals, which need to be managed manually by code
84 # below.
85
86 # - I also need to split up the color schemes from the prompt specials
87 # somehow. I don't have a clean design for that quite yet.
88
89 HOME = py3compat.str_to_unicode(os.environ.get("HOME","//////:::::ZZZZZ,,,~~~"))
90
91 # This is needed on FreeBSD, and maybe other systems which symlink /home to
92 # /usr/home, but retain the $HOME variable as pointing to /home
93 HOME = os.path.realpath(HOME)
94
95 # We precompute a few more strings here for the prompt_specials, which are
96 # fixed once ipython starts. This reduces the runtime overhead of computing
97 # prompt strings.
98 USER = py3compat.str_to_unicode(os.environ.get("USER",''))
99 HOSTNAME = py3compat.str_to_unicode(socket.gethostname())
100 HOSTNAME_SHORT = HOSTNAME.split(".")[0]
101
102 # IronPython doesn't currently have os.getuid() even if
103 # os.name == 'posix'; 2/8/2014
104 ROOT_SYMBOL = "#" if (os.name=='nt' or sys.platform=='cli' or os.getuid()==0) else "$"
105
106 prompt_abbreviations = {
107 # Prompt/history count
108 '%n' : '{color.number}' '{count}' '{color.prompt}',
109 r'\#': '{color.number}' '{count}' '{color.prompt}',
110 # Just the prompt counter number, WITHOUT any coloring wrappers, so users
111 # can get numbers displayed in whatever color they want.
112 r'\N': '{count}',
113
114 # Prompt/history count, with the actual digits replaced by dots or
115 # spaces. Used mainly in continuation prompts (prompt_in2).
116 r'\D': '{dots}',
117 r'\S': '{spaces}',
118
119 # Current time
120 r'\T' : '{time}',
121 # Current working directory
122 r'\w': '{cwd}',
123 # Basename of current working directory.
124 # (use os.sep to make this portable across OSes)
125 r'\W' : '{cwd_last}',
126 # These X<N> are an extension to the normal bash prompts. They return
127 # N terms of the path, after replacing $HOME with '~'
128 r'\X0': '{cwd_x[0]}',
129 r'\X1': '{cwd_x[1]}',
130 r'\X2': '{cwd_x[2]}',
131 r'\X3': '{cwd_x[3]}',
132 r'\X4': '{cwd_x[4]}',
133 r'\X5': '{cwd_x[5]}',
134 # Y<N> are similar to X<N>, but they show '~' if it's the directory
135 # N+1 in the list. Somewhat like %cN in tcsh.
136 r'\Y0': '{cwd_y[0]}',
137 r'\Y1': '{cwd_y[1]}',
138 r'\Y2': '{cwd_y[2]}',
139 r'\Y3': '{cwd_y[3]}',
140 r'\Y4': '{cwd_y[4]}',
141 r'\Y5': '{cwd_y[5]}',
142 # Hostname up to first .
143 r'\h': HOSTNAME_SHORT,
144 # Full hostname
145 r'\H': HOSTNAME,
146 # Username of current user
147 r'\u': USER,
148 # Escaped '\'
149 '\\\\': '\\',
150 # Newline
151 r'\n': '\n',
152 # Carriage return
153 r'\r': '\r',
154 # Release version
155 r'\v': release.version,
156 # Root symbol ($ or #)
157 r'\$': ROOT_SYMBOL,
158 }
159
160 #-----------------------------------------------------------------------------
161 # More utilities
162 #-----------------------------------------------------------------------------
163
164 def cwd_filt(depth):
165 """Return the last depth elements of the current working directory.
166
167 $HOME is always replaced with '~'.
168 If depth==0, the full path is returned."""
169
170 cwd = py3compat.getcwd().replace(HOME,"~")
171 out = os.sep.join(cwd.split(os.sep)[-depth:])
172 return out or os.sep
173
174 def cwd_filt2(depth):
175 """Return the last depth elements of the current working directory.
176
177 $HOME is always replaced with '~'.
178 If depth==0, the full path is returned."""
179
180 full_cwd = py3compat.getcwd()
181 cwd = full_cwd.replace(HOME,"~").split(os.sep)
182 if '~' in cwd and len(cwd) == depth+1:
183 depth += 1
184 drivepart = ''
185 if sys.platform == 'win32' and len(cwd) > depth:
186 drivepart = os.path.splitdrive(full_cwd)[0]
187 out = drivepart + '/'.join(cwd[-depth:])
188
189 return out or os.sep
190
191 #-----------------------------------------------------------------------------
192 # Prompt classes
193 #-----------------------------------------------------------------------------
194
195 lazily_evaluate = {'time': LazyEvaluate(time.strftime, "%H:%M:%S"),
196 'cwd': LazyEvaluate(py3compat.getcwd),
197 'cwd_last': LazyEvaluate(lambda: py3compat.getcwd().split(os.sep)[-1]),
198 'cwd_x': [LazyEvaluate(lambda: py3compat.getcwd().replace(HOME,"~"))] +\
199 [LazyEvaluate(cwd_filt, x) for x in range(1,6)],
200 'cwd_y': [LazyEvaluate(cwd_filt2, x) for x in range(6)]
201 }
202
203 def _lenlastline(s):
204 """Get the length of the last line. More intelligent than
205 len(s.splitlines()[-1]).
206 """
207 if not s or s.endswith(('\n', '\r')):
208 return 0
209 return len(s.splitlines()[-1])
210
211
212 invisible_chars_re = re.compile('\001[^\001\002]*\002')
213 def _invisible_characters(s):
214 """
215 Get the number of invisible ANSI characters in s. Invisible characters
216 must be delimited by \001 and \002.
217 """
218 return _lenlastline(s) - _lenlastline(invisible_chars_re.sub('', s))
219
220 class UserNSFormatter(Formatter):
221 """A Formatter that falls back on a shell's user_ns and __builtins__ for name resolution"""
222 def __init__(self, shell):
223 self.shell = shell
224
225 def get_value(self, key, args, kwargs):
226 # try regular formatting first:
227 try:
228 return Formatter.get_value(self, key, args, kwargs)
229 except Exception:
230 pass
231 # next, look in user_ns and builtins:
232 for container in (self.shell.user_ns, __builtins__):
233 if key in container:
234 return container[key]
235 # nothing found, put error message in its place
236 return "<ERROR: '%s' not found>" % key
237
238
239 class PromptManager(Configurable):
240 """This is the primary interface for producing IPython's prompts."""
241 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
242
243 color_scheme_table = Instance(coloransi.ColorSchemeTable, allow_none=True)
244 color_scheme = Unicode('Linux').tag(config=True)
245
246 @observe('color_scheme')
247 def _color_scheme_changed(self, change):
248 self.color_scheme_table.set_active_scheme(change['new'])
249 for pname in ['in', 'in2', 'out', 'rewrite']:
250 # We need to recalculate the number of invisible characters
251 self.update_prompt(pname)
252
253 lazy_evaluate_fields = Dict(help="""
254 This maps field names used in the prompt templates to functions which
255 will be called when the prompt is rendered. This allows us to include
256 things like the current time in the prompts. Functions are only called
257 if they are used in the prompt.
258 """)
259
260 in_template = Unicode('In [\\#]: ',
261 help="Input prompt. '\\#' will be transformed to the prompt number"
262 ).tag(config=True)
263 in2_template = Unicode(' .\\D.: ',
264 help="Continuation prompt.").tag(config=True)
265 out_template = Unicode('Out[\\#]: ',
266 help="Output prompt. '\\#' will be transformed to the prompt number"
267 ).tag(config=True)
268
269 @default('lazy_evaluate_fields')
270 def _lazy_evaluate_fields_default(self):
271 return lazily_evaluate.copy()
272
273 justify = Bool(True, help="""
274 If True (default), each prompt will be right-aligned with the
275 preceding one.
276 """).tag(config=True)
277
278 # We actually store the expanded templates here:
279 templates = Dict()
280
281 # The number of characters in the last prompt rendered, not including
282 # colour characters.
283 width = Int()
284 txtwidth = Int() # Not including right-justification
285
286 # The number of characters in each prompt which don't contribute to width
287 invisible_chars = Dict()
288
289 @default('invisible_chars')
290 def _invisible_chars_default(self):
291 return {'in': 0, 'in2': 0, 'out': 0, 'rewrite':0}
292
293 def __init__(self, shell, **kwargs):
294 super(PromptManager, self).__init__(shell=shell, **kwargs)
295
296 # Prepare colour scheme table
297 self.color_scheme_table = coloransi.ColorSchemeTable([NoColor,
298 LinuxColors, LightBGColors], self.color_scheme)
299
300 self._formatter = UserNSFormatter(shell)
301 # Prepare templates & numbers of invisible characters
302 self.update_prompt('in', self.in_template)
303 self.update_prompt('in2', self.in2_template)
304 self.update_prompt('out', self.out_template)
305 self.update_prompt('rewrite')
306 self.observe(self._update_prompt_trait,
307 names=['in_template', 'in2_template', 'out_template'])
308
309 def update_prompt(self, name, new_template=None):
310 """This is called when a prompt template is updated. It processes
311 abbreviations used in the prompt template (like \#) and calculates how
312 many invisible characters (ANSI colour escapes) the resulting prompt
313 contains.
314
315 It is also called for each prompt on changing the colour scheme. In both
316 cases, traitlets should take care of calling this automatically.
317 """
318 if new_template is not None:
319 self.templates[name] = multiple_replace(prompt_abbreviations, new_template)
320 # We count invisible characters (colour escapes) on the last line of the
321 # prompt, to calculate the width for lining up subsequent prompts.
322 invis_chars = _invisible_characters(self._render(name, color=True))
323 self.invisible_chars[name] = invis_chars
324
325 def _update_prompt_trait(self, changes):
326 traitname = changes['name']
327 new_template = changes['new']
328 name = traitname[:-9] # Cut off '_template'
329 self.update_prompt(name, new_template)
330
331 def _render(self, name, color=True, **kwargs):
332 """Render but don't justify, or update the width or txtwidth attributes.
333 """
334 if name == 'rewrite':
335 return self._render_rewrite(color=color)
336
337 if color:
338 scheme = self.color_scheme_table.active_colors
339 if name=='out':
340 colors = color_lists['normal']
341 colors.number, colors.prompt, colors.normal = \
342 scheme.out_number, scheme.out_prompt, scheme.normal
343 else:
344 colors = color_lists['inp']
345 colors.number, colors.prompt, colors.normal = \
346 scheme.in_number, scheme.in_prompt, scheme.in_normal
347 if name=='in2':
348 colors.prompt = scheme.in_prompt2
349 else:
350 # No color
351 colors = color_lists['nocolor']
352 colors.number, colors.prompt, colors.normal = '', '', ''
353
354 count = self.shell.execution_count # Shorthand
355 # Build the dictionary to be passed to string formatting
356 fmtargs = dict(color=colors, count=count,
357 dots="."*len(str(count)), spaces=" "*len(str(count)),
358 width=self.width, txtwidth=self.txtwidth)
359 fmtargs.update(self.lazy_evaluate_fields)
360 fmtargs.update(kwargs)
361
362 # Prepare the prompt
363 prompt = colors.prompt + self.templates[name] + colors.normal
364
365 # Fill in required fields
366 return self._formatter.format(prompt, **fmtargs)
367
368 def _render_rewrite(self, color=True):
369 """Render the ---> rewrite prompt."""
370 if color:
371 scheme = self.color_scheme_table.active_colors
372 # We need a non-input version of these escapes
373 color_prompt = scheme.in_prompt.replace("\001","").replace("\002","")
374 color_normal = scheme.normal
375 else:
376 color_prompt, color_normal = '', ''
377
378 return color_prompt + "-> ".rjust(self.txtwidth, "-") + color_normal
379
380 def render(self, name, color=True, just=None, **kwargs):
381 """
382 Render the selected prompt.
383
384 Parameters
385 ----------
386 name : str
387 Which prompt to render. One of 'in', 'in2', 'out', 'rewrite'
388 color : bool
389 If True (default), include ANSI escape sequences for a coloured prompt.
390 just : bool
391 If True, justify the prompt to the width of the last prompt. The
392 default is stored in self.justify.
393 **kwargs :
394 Additional arguments will be passed to the string formatting operation,
395 so they can override the values that would otherwise fill in the
396 template.
397
398 Returns
399 -------
400 A string containing the rendered prompt.
401 """
402 res = self._render(name, color=color, **kwargs)
403
404 # Handle justification of prompt
405 invis_chars = self.invisible_chars[name] if color else 0
406 self.txtwidth = _lenlastline(res) - invis_chars
407 just = self.justify if (just is None) else just
408 # If the prompt spans more than one line, don't try to justify it:
409 if just and name != 'in' and ('\n' not in res) and ('\r' not in res):
410 res = res.rjust(self.width + invis_chars)
411 self.width = _lenlastline(res) - invis_chars
412 return res
@@ -1,129 +1,37 b''
1 1 # -*- coding: utf-8
2 2 """Tests for prompt generation."""
3 3
4 4 import unittest
5 5
6 import os
7
8 from IPython.testing import tools as tt, decorators as dec
9 from IPython.core.prompts import PromptManager, LazyEvaluate, _invisible_characters
6 from IPython.core.prompts import LazyEvaluate
10 7 from IPython.testing.globalipapp import get_ipython
11 from IPython.utils.tempdir import TemporaryWorkingDirectory
12 from IPython.utils import py3compat
13 8 from IPython.utils.py3compat import unicode_type
14 9
15 10 ip = get_ipython()
16 11
17 12
18 13 class PromptTests(unittest.TestCase):
19 def setUp(self):
20 self.pm = PromptManager(shell=ip, config=ip.config)
21
22 def test_multiline_prompt(self):
23 self.pm.in_template = "[In]\n>>>"
24 self.pm.render('in')
25 self.assertEqual(self.pm.width, 3)
26 self.assertEqual(self.pm.txtwidth, 3)
27
28 self.pm.in_template = '[In]\n'
29 self.pm.render('in')
30 self.assertEqual(self.pm.width, 0)
31 self.assertEqual(self.pm.txtwidth, 0)
32
33 def test_translate_abbreviations(self):
34 def do_translate(template):
35 self.pm.in_template = template
36 return self.pm.templates['in']
37
38 pairs = [(r'%n>', '{color.number}{count}{color.prompt}>'),
39 (r'\T', '{time}'),
40 (r'\n', '\n')
41 ]
42
43 tt.check_pairs(do_translate, pairs)
44
45 def test_user_ns(self):
46 self.pm.color_scheme = 'NoColor'
47 ip.ex("foo='bar'")
48 self.pm.in_template = "In [{foo}]"
49 prompt = self.pm.render('in')
50 self.assertEqual(prompt, u'In [bar]')
51
52 def test_builtins(self):
53 self.pm.color_scheme = 'NoColor'
54 self.pm.in_template = "In [{int}]"
55 prompt = self.pm.render('in')
56 self.assertEqual(prompt, u"In [%r]" % int)
57
58 def test_undefined(self):
59 self.pm.color_scheme = 'NoColor'
60 self.pm.in_template = "In [{foo_dne}]"
61 prompt = self.pm.render('in')
62 self.assertEqual(prompt, u"In [<ERROR: 'foo_dne' not found>]")
63
64 def test_render(self):
65 self.pm.in_template = r'\#>'
66 self.assertEqual(self.pm.render('in',color=False), '%d>' % ip.execution_count)
67
68 @dec.onlyif_unicode_paths
69 def test_render_unicode_cwd(self):
70 with TemporaryWorkingDirectory(u'ΓΌnicΓΈdΓ©'):
71 self.pm.in_template = r'\w [\#]'
72 p = self.pm.render('in', color=False)
73 self.assertEqual(p, u"%s [%i]" % (py3compat.getcwd(), ip.execution_count))
74
75 14 def test_lazy_eval_unicode(self):
76 15 u = u'ΓΌnicΓΈdΓ©'
77 16 lz = LazyEvaluate(lambda : u)
78 17 # str(lz) would fail
79 18 self.assertEqual(unicode_type(lz), u)
80 19 self.assertEqual(format(lz), u)
81 20
82 21 def test_lazy_eval_nonascii_bytes(self):
83 22 u = u'ΓΌnicΓΈdΓ©'
84 23 b = u.encode('utf8')
85 24 lz = LazyEvaluate(lambda : b)
86 25 # unicode(lz) would fail
87 26 self.assertEqual(str(lz), str(b))
88 27 self.assertEqual(format(lz), str(b))
89 28
90 29 def test_lazy_eval_float(self):
91 30 f = 0.503
92 31 lz = LazyEvaluate(lambda : f)
93 32
94 33 self.assertEqual(str(lz), str(f))
95 34 self.assertEqual(unicode_type(lz), unicode_type(f))
96 35 self.assertEqual(format(lz), str(f))
97 36 self.assertEqual(format(lz, '.1'), '0.5')
98
99 @dec.skip_win32
100 def test_cwd_x(self):
101 self.pm.in_template = r"\X0"
102 save = py3compat.getcwd()
103 os.chdir(os.path.expanduser('~'))
104 p = self.pm.render('in', color=False)
105 try:
106 self.assertEqual(p, '~')
107 finally:
108 os.chdir(save)
109
110 def test_invisible_chars(self):
111 self.assertEqual(_invisible_characters('abc'), 0)
112 self.assertEqual(_invisible_characters('\001\033[1;37m\002'), 9)
113 # Sequences must be between \001 and \002 to be counted
114 self.assertEqual(_invisible_characters('\033[1;37m'), 0)
115 # Test custom escape sequences
116 self.assertEqual(_invisible_characters('\001\033]133;A\a\002'), 10)
117
118 def test_width(self):
119 default_in = '\x01\x1b]133;A\x07\x02In [1]: \x01\x1b]133;B\x07\x02'
120 self.pm.in_template = default_in
121 self.pm.render('in')
122 self.assertEqual(self.pm.width, 8)
123 self.assertEqual(self.pm.txtwidth, 8)
124 37
125 # Test custom escape sequences
126 self.pm.in_template = '\001\033]133;A\a\002' + default_in + '\001\033]133;B\a\002'
127 self.pm.render('in')
128 self.assertEqual(self.pm.width, 8)
129 self.assertEqual(self.pm.txtwidth, 8)
@@ -1,517 +1,510 b''
1 1 # encoding: utf-8
2 2 """Tests for code execution (%run and related), which is particularly tricky.
3 3
4 4 Because of how %run manages namespaces, and the fact that we are trying here to
5 5 verify subtle object deletion and reference counting issues, the %run tests
6 6 will be kept in this separate file. This makes it easier to aggregate in one
7 7 place the tricks needed to handle it; most other magics are much easier to test
8 8 and we do so in a common test_magic file.
9 9 """
10 10
11 11 # Copyright (c) IPython Development Team.
12 12 # Distributed under the terms of the Modified BSD License.
13 13
14 14 from __future__ import absolute_import
15 15
16 16
17 17 import functools
18 18 import os
19 19 from os.path import join as pjoin
20 20 import random
21 21 import sys
22 22 import tempfile
23 23 import textwrap
24 24 import unittest
25 25
26 26 try:
27 27 from unittest.mock import patch
28 28 except ImportError:
29 29 from mock import patch
30 30
31 31 import nose.tools as nt
32 32 from nose import SkipTest
33 33
34 34 from IPython.testing import decorators as dec
35 35 from IPython.testing import tools as tt
36 36 from IPython.utils import py3compat
37 37 from IPython.utils.io import capture_output
38 38 from IPython.utils.tempdir import TemporaryDirectory
39 39 from IPython.core import debugger
40 40
41 41
42 42 def doctest_refbug():
43 43 """Very nasty problem with references held by multiple runs of a script.
44 44 See: https://github.com/ipython/ipython/issues/141
45 45
46 46 In [1]: _ip.clear_main_mod_cache()
47 47 # random
48 48
49 49 In [2]: %run refbug
50 50
51 51 In [3]: call_f()
52 52 lowercased: hello
53 53
54 54 In [4]: %run refbug
55 55
56 56 In [5]: call_f()
57 57 lowercased: hello
58 58 lowercased: hello
59 59 """
60 60
61 61
62 62 def doctest_run_builtins():
63 63 r"""Check that %run doesn't damage __builtins__.
64 64
65 65 In [1]: import tempfile
66 66
67 67 In [2]: bid1 = id(__builtins__)
68 68
69 69 In [3]: fname = tempfile.mkstemp('.py')[1]
70 70
71 71 In [3]: f = open(fname,'w')
72 72
73 73 In [4]: dummy= f.write('pass\n')
74 74
75 75 In [5]: f.flush()
76 76
77 77 In [6]: t1 = type(__builtins__)
78 78
79 79 In [7]: %run $fname
80 80
81 81 In [7]: f.close()
82 82
83 83 In [8]: bid2 = id(__builtins__)
84 84
85 85 In [9]: t2 = type(__builtins__)
86 86
87 87 In [10]: t1 == t2
88 88 Out[10]: True
89 89
90 90 In [10]: bid1 == bid2
91 91 Out[10]: True
92 92
93 93 In [12]: try:
94 94 ....: os.unlink(fname)
95 95 ....: except:
96 96 ....: pass
97 97 ....:
98 98 """
99 99
100 100
101 101 def doctest_run_option_parser():
102 102 r"""Test option parser in %run.
103 103
104 104 In [1]: %run print_argv.py
105 105 []
106 106
107 107 In [2]: %run print_argv.py print*.py
108 108 ['print_argv.py']
109 109
110 110 In [3]: %run -G print_argv.py print*.py
111 111 ['print*.py']
112 112
113 113 """
114 114
115 115
116 116 @dec.skip_win32
117 117 def doctest_run_option_parser_for_posix():
118 118 r"""Test option parser in %run (Linux/OSX specific).
119 119
120 120 You need double quote to escape glob in POSIX systems:
121 121
122 122 In [1]: %run print_argv.py print\\*.py
123 123 ['print*.py']
124 124
125 125 You can't use quote to escape glob in POSIX systems:
126 126
127 127 In [2]: %run print_argv.py 'print*.py'
128 128 ['print_argv.py']
129 129
130 130 """
131 131
132 132
133 133 @dec.skip_if_not_win32
134 134 def doctest_run_option_parser_for_windows():
135 135 r"""Test option parser in %run (Windows specific).
136 136
137 137 In Windows, you can't escape ``*` `by backslash:
138 138
139 139 In [1]: %run print_argv.py print\\*.py
140 140 ['print\\*.py']
141 141
142 142 You can use quote to escape glob:
143 143
144 144 In [2]: %run print_argv.py 'print*.py'
145 145 ['print*.py']
146 146
147 147 """
148 148
149 149
150 150 @py3compat.doctest_refactor_print
151 151 def doctest_reset_del():
152 152 """Test that resetting doesn't cause errors in __del__ methods.
153 153
154 154 In [2]: class A(object):
155 155 ...: def __del__(self):
156 156 ...: print str("Hi")
157 157 ...:
158 158
159 159 In [3]: a = A()
160 160
161 161 In [4]: get_ipython().reset()
162 162 Hi
163 163
164 164 In [5]: 1+1
165 165 Out[5]: 2
166 166 """
167 167
168 168 # For some tests, it will be handy to organize them in a class with a common
169 169 # setup that makes a temp file
170 170
171 171 class TestMagicRunPass(tt.TempFileMixin):
172 172
173 173 def setup(self):
174 174 """Make a valid python temp file."""
175 175 self.mktmp('pass\n')
176 176
177 177 def run_tmpfile(self):
178 178 _ip = get_ipython()
179 179 # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
180 180 # See below and ticket https://bugs.launchpad.net/bugs/366353
181 181 _ip.magic('run %s' % self.fname)
182 182
183 183 def run_tmpfile_p(self):
184 184 _ip = get_ipython()
185 185 # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
186 186 # See below and ticket https://bugs.launchpad.net/bugs/366353
187 187 _ip.magic('run -p %s' % self.fname)
188 188
189 189 def test_builtins_id(self):
190 190 """Check that %run doesn't damage __builtins__ """
191 191 _ip = get_ipython()
192 192 # Test that the id of __builtins__ is not modified by %run
193 193 bid1 = id(_ip.user_ns['__builtins__'])
194 194 self.run_tmpfile()
195 195 bid2 = id(_ip.user_ns['__builtins__'])
196 196 nt.assert_equal(bid1, bid2)
197 197
198 198 def test_builtins_type(self):
199 199 """Check that the type of __builtins__ doesn't change with %run.
200 200
201 201 However, the above could pass if __builtins__ was already modified to
202 202 be a dict (it should be a module) by a previous use of %run. So we
203 203 also check explicitly that it really is a module:
204 204 """
205 205 _ip = get_ipython()
206 206 self.run_tmpfile()
207 207 nt.assert_equal(type(_ip.user_ns['__builtins__']),type(sys))
208
209 def test_prompts(self):
210 """Test that prompts correctly generate after %run"""
211 self.run_tmpfile()
212 _ip = get_ipython()
213 p2 = _ip.prompt_manager.render('in2').strip()
214 nt.assert_equal(p2[:3], '...')
215 208
216 209 def test_run_profile( self ):
217 210 """Test that the option -p, which invokes the profiler, do not
218 211 crash by invoking execfile"""
219 212 _ip = get_ipython()
220 213 self.run_tmpfile_p()
221 214
222 215
223 216 class TestMagicRunSimple(tt.TempFileMixin):
224 217
225 218 def test_simpledef(self):
226 219 """Test that simple class definitions work."""
227 220 src = ("class foo: pass\n"
228 221 "def f(): return foo()")
229 222 self.mktmp(src)
230 223 _ip.magic('run %s' % self.fname)
231 224 _ip.run_cell('t = isinstance(f(), foo)')
232 225 nt.assert_true(_ip.user_ns['t'])
233 226
234 227 def test_obj_del(self):
235 228 """Test that object's __del__ methods are called on exit."""
236 229 if sys.platform == 'win32':
237 230 try:
238 231 import win32api
239 232 except ImportError:
240 233 raise SkipTest("Test requires pywin32")
241 234 src = ("class A(object):\n"
242 235 " def __del__(self):\n"
243 236 " print 'object A deleted'\n"
244 237 "a = A()\n")
245 238 self.mktmp(py3compat.doctest_refactor_print(src))
246 239 if dec.module_not_available('sqlite3'):
247 240 err = 'WARNING: IPython History requires SQLite, your history will not be saved\n'
248 241 else:
249 242 err = None
250 243 tt.ipexec_validate(self.fname, 'object A deleted', err)
251 244
252 245 def test_aggressive_namespace_cleanup(self):
253 246 """Test that namespace cleanup is not too aggressive GH-238
254 247
255 248 Returning from another run magic deletes the namespace"""
256 249 # see ticket https://github.com/ipython/ipython/issues/238
257 250
258 251 with tt.TempFileMixin() as empty:
259 252 empty.mktmp('')
260 253 # On Windows, the filename will have \users in it, so we need to use the
261 254 # repr so that the \u becomes \\u.
262 255 src = ("ip = get_ipython()\n"
263 256 "for i in range(5):\n"
264 257 " try:\n"
265 258 " ip.magic(%r)\n"
266 259 " except NameError as e:\n"
267 260 " print(i)\n"
268 261 " break\n" % ('run ' + empty.fname))
269 262 self.mktmp(src)
270 263 _ip.magic('run %s' % self.fname)
271 264 _ip.run_cell('ip == get_ipython()')
272 265 nt.assert_equal(_ip.user_ns['i'], 4)
273 266
274 267 def test_run_second(self):
275 268 """Test that running a second file doesn't clobber the first, gh-3547
276 269 """
277 270 self.mktmp("avar = 1\n"
278 271 "def afunc():\n"
279 272 " return avar\n")
280 273
281 274 with tt.TempFileMixin() as empty:
282 275 empty.mktmp("")
283 276
284 277 _ip.magic('run %s' % self.fname)
285 278 _ip.magic('run %s' % empty.fname)
286 279 nt.assert_equal(_ip.user_ns['afunc'](), 1)
287 280
288 281 @dec.skip_win32
289 282 def test_tclass(self):
290 283 mydir = os.path.dirname(__file__)
291 284 tc = os.path.join(mydir, 'tclass')
292 285 src = ("%%run '%s' C-first\n"
293 286 "%%run '%s' C-second\n"
294 287 "%%run '%s' C-third\n") % (tc, tc, tc)
295 288 self.mktmp(src, '.ipy')
296 289 out = """\
297 290 ARGV 1-: ['C-first']
298 291 ARGV 1-: ['C-second']
299 292 tclass.py: deleting object: C-first
300 293 ARGV 1-: ['C-third']
301 294 tclass.py: deleting object: C-second
302 295 tclass.py: deleting object: C-third
303 296 """
304 297 if dec.module_not_available('sqlite3'):
305 298 err = 'WARNING: IPython History requires SQLite, your history will not be saved\n'
306 299 else:
307 300 err = None
308 301 tt.ipexec_validate(self.fname, out, err)
309 302
310 303 def test_run_i_after_reset(self):
311 304 """Check that %run -i still works after %reset (gh-693)"""
312 305 src = "yy = zz\n"
313 306 self.mktmp(src)
314 307 _ip.run_cell("zz = 23")
315 308 _ip.magic('run -i %s' % self.fname)
316 309 nt.assert_equal(_ip.user_ns['yy'], 23)
317 310 _ip.magic('reset -f')
318 311 _ip.run_cell("zz = 23")
319 312 _ip.magic('run -i %s' % self.fname)
320 313 nt.assert_equal(_ip.user_ns['yy'], 23)
321 314
322 315 def test_unicode(self):
323 316 """Check that files in odd encodings are accepted."""
324 317 mydir = os.path.dirname(__file__)
325 318 na = os.path.join(mydir, 'nonascii.py')
326 319 _ip.magic('run "%s"' % na)
327 320 nt.assert_equal(_ip.user_ns['u'], u'ΠŽΡ‚β„–Π€')
328 321
329 322 def test_run_py_file_attribute(self):
330 323 """Test handling of `__file__` attribute in `%run <file>.py`."""
331 324 src = "t = __file__\n"
332 325 self.mktmp(src)
333 326 _missing = object()
334 327 file1 = _ip.user_ns.get('__file__', _missing)
335 328 _ip.magic('run %s' % self.fname)
336 329 file2 = _ip.user_ns.get('__file__', _missing)
337 330
338 331 # Check that __file__ was equal to the filename in the script's
339 332 # namespace.
340 333 nt.assert_equal(_ip.user_ns['t'], self.fname)
341 334
342 335 # Check that __file__ was not leaked back into user_ns.
343 336 nt.assert_equal(file1, file2)
344 337
345 338 def test_run_ipy_file_attribute(self):
346 339 """Test handling of `__file__` attribute in `%run <file.ipy>`."""
347 340 src = "t = __file__\n"
348 341 self.mktmp(src, ext='.ipy')
349 342 _missing = object()
350 343 file1 = _ip.user_ns.get('__file__', _missing)
351 344 _ip.magic('run %s' % self.fname)
352 345 file2 = _ip.user_ns.get('__file__', _missing)
353 346
354 347 # Check that __file__ was equal to the filename in the script's
355 348 # namespace.
356 349 nt.assert_equal(_ip.user_ns['t'], self.fname)
357 350
358 351 # Check that __file__ was not leaked back into user_ns.
359 352 nt.assert_equal(file1, file2)
360 353
361 354 def test_run_formatting(self):
362 355 """ Test that %run -t -N<N> does not raise a TypeError for N > 1."""
363 356 src = "pass"
364 357 self.mktmp(src)
365 358 _ip.magic('run -t -N 1 %s' % self.fname)
366 359 _ip.magic('run -t -N 10 %s' % self.fname)
367 360
368 361 def test_ignore_sys_exit(self):
369 362 """Test the -e option to ignore sys.exit()"""
370 363 src = "import sys; sys.exit(1)"
371 364 self.mktmp(src)
372 365 with tt.AssertPrints('SystemExit'):
373 366 _ip.magic('run %s' % self.fname)
374 367
375 368 with tt.AssertNotPrints('SystemExit'):
376 369 _ip.magic('run -e %s' % self.fname)
377 370
378 371 @dec.skip_without('nbformat') # Requires jsonschema
379 372 def test_run_nb(self):
380 373 """Test %run notebook.ipynb"""
381 374 from nbformat import v4, writes
382 375 nb = v4.new_notebook(
383 376 cells=[
384 377 v4.new_markdown_cell("The Ultimate Question of Everything"),
385 378 v4.new_code_cell("answer=42")
386 379 ]
387 380 )
388 381 src = writes(nb, version=4)
389 382 self.mktmp(src, ext='.ipynb')
390 383
391 384 _ip.magic("run %s" % self.fname)
392 385
393 386 nt.assert_equal(_ip.user_ns['answer'], 42)
394 387
395 388
396 389
397 390 class TestMagicRunWithPackage(unittest.TestCase):
398 391
399 392 def writefile(self, name, content):
400 393 path = os.path.join(self.tempdir.name, name)
401 394 d = os.path.dirname(path)
402 395 if not os.path.isdir(d):
403 396 os.makedirs(d)
404 397 with open(path, 'w') as f:
405 398 f.write(textwrap.dedent(content))
406 399
407 400 def setUp(self):
408 401 self.package = package = 'tmp{0}'.format(repr(random.random())[2:])
409 402 """Temporary valid python package name."""
410 403
411 404 self.value = int(random.random() * 10000)
412 405
413 406 self.tempdir = TemporaryDirectory()
414 407 self.__orig_cwd = py3compat.getcwd()
415 408 sys.path.insert(0, self.tempdir.name)
416 409
417 410 self.writefile(os.path.join(package, '__init__.py'), '')
418 411 self.writefile(os.path.join(package, 'sub.py'), """
419 412 x = {0!r}
420 413 """.format(self.value))
421 414 self.writefile(os.path.join(package, 'relative.py'), """
422 415 from .sub import x
423 416 """)
424 417 self.writefile(os.path.join(package, 'absolute.py'), """
425 418 from {0}.sub import x
426 419 """.format(package))
427 420
428 421 def tearDown(self):
429 422 os.chdir(self.__orig_cwd)
430 423 sys.path[:] = [p for p in sys.path if p != self.tempdir.name]
431 424 self.tempdir.cleanup()
432 425
433 426 def check_run_submodule(self, submodule, opts=''):
434 427 _ip.user_ns.pop('x', None)
435 428 _ip.magic('run {2} -m {0}.{1}'.format(self.package, submodule, opts))
436 429 self.assertEqual(_ip.user_ns['x'], self.value,
437 430 'Variable `x` is not loaded from module `{0}`.'
438 431 .format(submodule))
439 432
440 433 def test_run_submodule_with_absolute_import(self):
441 434 self.check_run_submodule('absolute')
442 435
443 436 def test_run_submodule_with_relative_import(self):
444 437 """Run submodule that has a relative import statement (#2727)."""
445 438 self.check_run_submodule('relative')
446 439
447 440 def test_prun_submodule_with_absolute_import(self):
448 441 self.check_run_submodule('absolute', '-p')
449 442
450 443 def test_prun_submodule_with_relative_import(self):
451 444 self.check_run_submodule('relative', '-p')
452 445
453 446 def with_fake_debugger(func):
454 447 @functools.wraps(func)
455 448 def wrapper(*args, **kwds):
456 449 with patch.object(debugger.Pdb, 'run', staticmethod(eval)):
457 450 return func(*args, **kwds)
458 451 return wrapper
459 452
460 453 @with_fake_debugger
461 454 def test_debug_run_submodule_with_absolute_import(self):
462 455 self.check_run_submodule('absolute', '-d')
463 456
464 457 @with_fake_debugger
465 458 def test_debug_run_submodule_with_relative_import(self):
466 459 self.check_run_submodule('relative', '-d')
467 460
468 461 def test_run__name__():
469 462 with TemporaryDirectory() as td:
470 463 path = pjoin(td, 'foo.py')
471 464 with open(path, 'w') as f:
472 465 f.write("q = __name__")
473 466
474 467 _ip.user_ns.pop('q', None)
475 468 _ip.magic('run {}'.format(path))
476 469 nt.assert_equal(_ip.user_ns.pop('q'), '__main__')
477 470
478 471 _ip.magic('run -n {}'.format(path))
479 472 nt.assert_equal(_ip.user_ns.pop('q'), 'foo')
480 473
481 474 def test_run_tb():
482 475 """Test traceback offset in %run"""
483 476 with TemporaryDirectory() as td:
484 477 path = pjoin(td, 'foo.py')
485 478 with open(path, 'w') as f:
486 479 f.write('\n'.join([
487 480 "def foo():",
488 481 " return bar()",
489 482 "def bar():",
490 483 " raise RuntimeError('hello!')",
491 484 "foo()",
492 485 ]))
493 486 with capture_output() as io:
494 487 _ip.magic('run {}'.format(path))
495 488 out = io.stdout
496 489 nt.assert_not_in("execfile", out)
497 490 nt.assert_in("RuntimeError", out)
498 491 nt.assert_equal(out.count("---->"), 3)
499 492
500 493 @dec.knownfailureif(sys.platform == 'win32', "writes to io.stdout aren't captured on Windows")
501 494 def test_script_tb():
502 495 """Test traceback offset in `ipython script.py`"""
503 496 with TemporaryDirectory() as td:
504 497 path = pjoin(td, 'foo.py')
505 498 with open(path, 'w') as f:
506 499 f.write('\n'.join([
507 500 "def foo():",
508 501 " return bar()",
509 502 "def bar():",
510 503 " raise RuntimeError('hello!')",
511 504 "foo()",
512 505 ]))
513 506 out, err = tt.ipexec(path)
514 507 nt.assert_not_in("execfile", out)
515 508 nt.assert_in("RuntimeError", out)
516 509 nt.assert_equal(out.count("---->"), 3)
517 510
@@ -1,70 +1,68 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Tests for shellapp module.
3 3
4 4 Authors
5 5 -------
6 6 * Bradley Froehle
7 7 """
8 8 #-----------------------------------------------------------------------------
9 9 # Copyright (C) 2012 The IPython Development Team
10 10 #
11 11 # Distributed under the terms of the BSD License. The full license is in
12 12 # the file COPYING, distributed as part of this software.
13 13 #-----------------------------------------------------------------------------
14 14
15 15 #-----------------------------------------------------------------------------
16 16 # Imports
17 17 #-----------------------------------------------------------------------------
18 18 import unittest
19 19
20 20 from IPython.testing import decorators as dec
21 21 from IPython.testing import tools as tt
22 22 from IPython.utils.py3compat import PY3
23 23
24 24 sqlite_err_maybe = dec.module_not_available('sqlite3')
25 25 SQLITE_NOT_AVAILABLE_ERROR = ('WARNING: IPython History requires SQLite,'
26 26 ' your history will not be saved\n')
27 27
28 28 class TestFileToRun(unittest.TestCase, tt.TempFileMixin):
29 29 """Test the behavior of the file_to_run parameter."""
30 30
31 31 def test_py_script_file_attribute(self):
32 32 """Test that `__file__` is set when running `ipython file.py`"""
33 33 src = "print(__file__)\n"
34 34 self.mktmp(src)
35 35
36 36 err = SQLITE_NOT_AVAILABLE_ERROR if sqlite_err_maybe else None
37 37 tt.ipexec_validate(self.fname, self.fname, err)
38 38
39 39 def test_ipy_script_file_attribute(self):
40 40 """Test that `__file__` is set when running `ipython file.ipy`"""
41 41 src = "print(__file__)\n"
42 42 self.mktmp(src, ext='.ipy')
43 43
44 44 err = SQLITE_NOT_AVAILABLE_ERROR if sqlite_err_maybe else None
45 45 tt.ipexec_validate(self.fname, self.fname, err)
46 46
47 47 # The commands option to ipexec_validate doesn't work on Windows, and it
48 48 # doesn't seem worth fixing
49 49 @dec.skip_win32
50 50 def test_py_script_file_attribute_interactively(self):
51 51 """Test that `__file__` is not set after `ipython -i file.py`"""
52 52 src = "True\n"
53 53 self.mktmp(src)
54 54
55 out = 'In [1]: False\n\nIn [2]:'
56 err = SQLITE_NOT_AVAILABLE_ERROR if sqlite_err_maybe else None
57 tt.ipexec_validate(self.fname, out, err, options=['-i'],
55 out, err = tt.ipexec(self.fname, options=['-i'],
58 56 commands=['"__file__" in globals()', 'exit()'])
57 self.assertIn("False", out)
59 58
60 59 @dec.skip_win32
61 60 @dec.skipif(PY3)
62 61 def test_py_script_file_compiler_directive(self):
63 62 """Test `__future__` compiler directives with `ipython -i file.py`"""
64 63 src = "from __future__ import division\n"
65 64 self.mktmp(src)
66 65
67 out = 'In [1]: float\n\nIn [2]:'
68 err = SQLITE_NOT_AVAILABLE_ERROR if sqlite_err_maybe else None
69 tt.ipexec_validate(self.fname, out, err, options=['-i'],
66 out, err = tt.ipexec(self.fname, options=['-i'],
70 67 commands=['type(1/2)', 'exit()'])
68 self.assertIn('float', out)
@@ -1,1186 +1,1185 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 Sphinx directive to support embedded IPython code.
4 4
5 5 This directive allows pasting of entire interactive IPython sessions, prompts
6 6 and all, and their code will actually get re-executed at doc build time, with
7 7 all prompts renumbered sequentially. It also allows you to input code as a pure
8 8 python input by giving the argument python to the directive. The output looks
9 9 like an interactive ipython section.
10 10
11 11 To enable this directive, simply list it in your Sphinx ``conf.py`` file
12 12 (making sure the directory where you placed it is visible to sphinx, as is
13 13 needed for all Sphinx directives). For example, to enable syntax highlighting
14 14 and the IPython directive::
15 15
16 16 extensions = ['IPython.sphinxext.ipython_console_highlighting',
17 17 'IPython.sphinxext.ipython_directive']
18 18
19 19 The IPython directive outputs code-blocks with the language 'ipython'. So
20 20 if you do not have the syntax highlighting extension enabled as well, then
21 21 all rendered code-blocks will be uncolored. By default this directive assumes
22 22 that your prompts are unchanged IPython ones, but this can be customized.
23 23 The configurable options that can be placed in conf.py are:
24 24
25 25 ipython_savefig_dir:
26 26 The directory in which to save the figures. This is relative to the
27 27 Sphinx source directory. The default is `html_static_path`.
28 28 ipython_rgxin:
29 29 The compiled regular expression to denote the start of IPython input
30 30 lines. The default is re.compile('In \[(\d+)\]:\s?(.*)\s*'). You
31 31 shouldn't need to change this.
32 32 ipython_rgxout:
33 33 The compiled regular expression to denote the start of IPython output
34 34 lines. The default is re.compile('Out\[(\d+)\]:\s?(.*)\s*'). You
35 35 shouldn't need to change this.
36 36 ipython_promptin:
37 37 The string to represent the IPython input prompt in the generated ReST.
38 38 The default is 'In [%d]:'. This expects that the line numbers are used
39 39 in the prompt.
40 40 ipython_promptout:
41 41 The string to represent the IPython prompt in the generated ReST. The
42 42 default is 'Out [%d]:'. This expects that the line numbers are used
43 43 in the prompt.
44 44 ipython_mplbackend:
45 45 The string which specifies if the embedded Sphinx shell should import
46 46 Matplotlib and set the backend. The value specifies a backend that is
47 47 passed to `matplotlib.use()` before any lines in `ipython_execlines` are
48 48 executed. If not specified in conf.py, then the default value of 'agg' is
49 49 used. To use the IPython directive without matplotlib as a dependency, set
50 50 the value to `None`. It may end up that matplotlib is still imported
51 51 if the user specifies so in `ipython_execlines` or makes use of the
52 52 @savefig pseudo decorator.
53 53 ipython_execlines:
54 54 A list of strings to be exec'd in the embedded Sphinx shell. Typical
55 55 usage is to make certain packages always available. Set this to an empty
56 56 list if you wish to have no imports always available. If specified in
57 57 conf.py as `None`, then it has the effect of making no imports available.
58 58 If omitted from conf.py altogether, then the default value of
59 59 ['import numpy as np', 'import matplotlib.pyplot as plt'] is used.
60 60 ipython_holdcount
61 61 When the @suppress pseudo-decorator is used, the execution count can be
62 62 incremented or not. The default behavior is to hold the execution count,
63 63 corresponding to a value of `True`. Set this to `False` to increment
64 64 the execution count after each suppressed command.
65 65
66 66 As an example, to use the IPython directive when `matplotlib` is not available,
67 67 one sets the backend to `None`::
68 68
69 69 ipython_mplbackend = None
70 70
71 71 An example usage of the directive is:
72 72
73 73 .. code-block:: rst
74 74
75 75 .. ipython::
76 76
77 77 In [1]: x = 1
78 78
79 79 In [2]: y = x**2
80 80
81 81 In [3]: print(y)
82 82
83 83 See http://matplotlib.org/sampledoc/ipython_directive.html for additional
84 84 documentation.
85 85
86 86 Pseudo-Decorators
87 87 =================
88 88
89 89 Note: Only one decorator is supported per input. If more than one decorator
90 90 is specified, then only the last one is used.
91 91
92 92 In addition to the Pseudo-Decorators/options described at the above link,
93 93 several enhancements have been made. The directive will emit a message to the
94 94 console at build-time if code-execution resulted in an exception or warning.
95 95 You can suppress these on a per-block basis by specifying the :okexcept:
96 96 or :okwarning: options:
97 97
98 98 .. code-block:: rst
99 99
100 100 .. ipython::
101 101 :okexcept:
102 102 :okwarning:
103 103
104 104 In [1]: 1/0
105 105 In [2]: # raise warning.
106 106
107 107 ToDo
108 108 ----
109 109
110 110 - Turn the ad-hoc test() function into a real test suite.
111 111 - Break up ipython-specific functionality from matplotlib stuff into better
112 112 separated code.
113 113
114 114 Authors
115 115 -------
116 116
117 117 - John D Hunter: orignal author.
118 118 - Fernando Perez: refactoring, documentation, cleanups, port to 0.11.
119 119 - VΓ‘clavΕ milauer <eudoxos-AT-arcig.cz>: Prompt generalizations.
120 120 - Skipper Seabold, refactoring, cleanups, pure python addition
121 121 """
122 122 from __future__ import print_function
123 123
124 124 #-----------------------------------------------------------------------------
125 125 # Imports
126 126 #-----------------------------------------------------------------------------
127 127
128 128 # Stdlib
129 129 import atexit
130 130 import os
131 131 import re
132 132 import sys
133 133 import tempfile
134 134 import ast
135 135 import warnings
136 136 import shutil
137 137
138 138
139 139 # Third-party
140 140 from docutils.parsers.rst import directives
141 141 from sphinx.util.compat import Directive
142 142
143 143 # Our own
144 144 from traitlets.config import Config
145 145 from IPython import InteractiveShell
146 146 from IPython.core.profiledir import ProfileDir
147 147 from IPython.utils import io
148 148 from IPython.utils.py3compat import PY3
149 149
150 150 if PY3:
151 151 from io import StringIO
152 152 else:
153 153 from StringIO import StringIO
154 154
155 155 #-----------------------------------------------------------------------------
156 156 # Globals
157 157 #-----------------------------------------------------------------------------
158 158 # for tokenizing blocks
159 159 COMMENT, INPUT, OUTPUT = range(3)
160 160
161 161 #-----------------------------------------------------------------------------
162 162 # Functions and class declarations
163 163 #-----------------------------------------------------------------------------
164 164
165 165 def block_parser(part, rgxin, rgxout, fmtin, fmtout):
166 166 """
167 167 part is a string of ipython text, comprised of at most one
168 168 input, one output, comments, and blank lines. The block parser
169 169 parses the text into a list of::
170 170
171 171 blocks = [ (TOKEN0, data0), (TOKEN1, data1), ...]
172 172
173 173 where TOKEN is one of [COMMENT | INPUT | OUTPUT ] and
174 174 data is, depending on the type of token::
175 175
176 176 COMMENT : the comment string
177 177
178 178 INPUT: the (DECORATOR, INPUT_LINE, REST) where
179 179 DECORATOR: the input decorator (or None)
180 180 INPUT_LINE: the input as string (possibly multi-line)
181 181 REST : any stdout generated by the input line (not OUTPUT)
182 182
183 183 OUTPUT: the output string, possibly multi-line
184 184
185 185 """
186 186 block = []
187 187 lines = part.split('\n')
188 188 N = len(lines)
189 189 i = 0
190 190 decorator = None
191 191 while 1:
192 192
193 193 if i==N:
194 194 # nothing left to parse -- the last line
195 195 break
196 196
197 197 line = lines[i]
198 198 i += 1
199 199 line_stripped = line.strip()
200 200 if line_stripped.startswith('#'):
201 201 block.append((COMMENT, line))
202 202 continue
203 203
204 204 if line_stripped.startswith('@'):
205 205 # Here is where we assume there is, at most, one decorator.
206 206 # Might need to rethink this.
207 207 decorator = line_stripped
208 208 continue
209 209
210 210 # does this look like an input line?
211 211 matchin = rgxin.match(line)
212 212 if matchin:
213 213 lineno, inputline = int(matchin.group(1)), matchin.group(2)
214 214
215 215 # the ....: continuation string
216 216 continuation = ' %s:'%''.join(['.']*(len(str(lineno))+2))
217 217 Nc = len(continuation)
218 218 # input lines can continue on for more than one line, if
219 219 # we have a '\' line continuation char or a function call
220 220 # echo line 'print'. The input line can only be
221 221 # terminated by the end of the block or an output line, so
222 222 # we parse out the rest of the input line if it is
223 223 # multiline as well as any echo text
224 224
225 225 rest = []
226 226 while i<N:
227 227
228 228 # look ahead; if the next line is blank, or a comment, or
229 229 # an output line, we're done
230 230
231 231 nextline = lines[i]
232 232 matchout = rgxout.match(nextline)
233 233 #print "nextline=%s, continuation=%s, starts=%s"%(nextline, continuation, nextline.startswith(continuation))
234 234 if matchout or nextline.startswith('#'):
235 235 break
236 236 elif nextline.startswith(continuation):
237 237 # The default ipython_rgx* treat the space following the colon as optional.
238 238 # However, If the space is there we must consume it or code
239 239 # employing the cython_magic extension will fail to execute.
240 240 #
241 241 # This works with the default ipython_rgx* patterns,
242 242 # If you modify them, YMMV.
243 243 nextline = nextline[Nc:]
244 244 if nextline and nextline[0] == ' ':
245 245 nextline = nextline[1:]
246 246
247 247 inputline += '\n' + nextline
248 248 else:
249 249 rest.append(nextline)
250 250 i+= 1
251 251
252 252 block.append((INPUT, (decorator, inputline, '\n'.join(rest))))
253 253 continue
254 254
255 255 # if it looks like an output line grab all the text to the end
256 256 # of the block
257 257 matchout = rgxout.match(line)
258 258 if matchout:
259 259 lineno, output = int(matchout.group(1)), matchout.group(2)
260 260 if i<N-1:
261 261 output = '\n'.join([output] + lines[i:])
262 262
263 263 block.append((OUTPUT, output))
264 264 break
265 265
266 266 return block
267 267
268 268
269 269 class EmbeddedSphinxShell(object):
270 270 """An embedded IPython instance to run inside Sphinx"""
271 271
272 272 def __init__(self, exec_lines=None):
273 273
274 274 self.cout = StringIO()
275 275
276 276 if exec_lines is None:
277 277 exec_lines = []
278 278
279 279 # Create config object for IPython
280 280 config = Config()
281 281 config.HistoryManager.hist_file = ':memory:'
282 282 config.InteractiveShell.autocall = False
283 283 config.InteractiveShell.autoindent = False
284 284 config.InteractiveShell.colors = 'NoColor'
285 285
286 286 # create a profile so instance history isn't saved
287 287 tmp_profile_dir = tempfile.mkdtemp(prefix='profile_')
288 288 profname = 'auto_profile_sphinx_build'
289 289 pdir = os.path.join(tmp_profile_dir,profname)
290 290 profile = ProfileDir.create_profile_dir(pdir)
291 291
292 292 # Create and initialize global ipython, but don't start its mainloop.
293 293 # This will persist across different EmbededSphinxShell instances.
294 294 IP = InteractiveShell.instance(config=config, profile_dir=profile)
295 295 atexit.register(self.cleanup)
296 296
297 297 # io.stdout redirect must be done after instantiating InteractiveShell
298 298 io.stdout = self.cout
299 299 io.stderr = self.cout
300 300
301 301 # For debugging, so we can see normal output, use this:
302 302 #from IPython.utils.io import Tee
303 303 #io.stdout = Tee(self.cout, channel='stdout') # dbg
304 304 #io.stderr = Tee(self.cout, channel='stderr') # dbg
305 305
306 306 # Store a few parts of IPython we'll need.
307 307 self.IP = IP
308 308 self.user_ns = self.IP.user_ns
309 309 self.user_global_ns = self.IP.user_global_ns
310 310
311 311 self.input = ''
312 312 self.output = ''
313 313 self.tmp_profile_dir = tmp_profile_dir
314 314
315 315 self.is_verbatim = False
316 316 self.is_doctest = False
317 317 self.is_suppress = False
318 318
319 319 # Optionally, provide more detailed information to shell.
320 320 # this is assigned by the SetUp method of IPythonDirective
321 321 # to point at itself.
322 322 #
323 323 # So, you can access handy things at self.directive.state
324 324 self.directive = None
325 325
326 326 # on the first call to the savefig decorator, we'll import
327 327 # pyplot as plt so we can make a call to the plt.gcf().savefig
328 328 self._pyplot_imported = False
329 329
330 330 # Prepopulate the namespace.
331 331 for line in exec_lines:
332 332 self.process_input_line(line, store_history=False)
333 333
334 334 def cleanup(self):
335 335 shutil.rmtree(self.tmp_profile_dir, ignore_errors=True)
336 336
337 337 def clear_cout(self):
338 338 self.cout.seek(0)
339 339 self.cout.truncate(0)
340 340
341 341 def process_input_line(self, line, store_history=True):
342 342 """process the input, capturing stdout"""
343 343
344 344 stdout = sys.stdout
345 345 splitter = self.IP.input_splitter
346 346 try:
347 347 sys.stdout = self.cout
348 348 splitter.push(line)
349 349 more = splitter.push_accepts_more()
350 350 if not more:
351 351 source_raw = splitter.raw_reset()
352 352 self.IP.run_cell(source_raw, store_history=store_history)
353 353 finally:
354 354 sys.stdout = stdout
355 355
356 356 def process_image(self, decorator):
357 357 """
358 358 # build out an image directive like
359 359 # .. image:: somefile.png
360 360 # :width 4in
361 361 #
362 362 # from an input like
363 363 # savefig somefile.png width=4in
364 364 """
365 365 savefig_dir = self.savefig_dir
366 366 source_dir = self.source_dir
367 367 saveargs = decorator.split(' ')
368 368 filename = saveargs[1]
369 369 # insert relative path to image file in source
370 370 outfile = os.path.relpath(os.path.join(savefig_dir,filename),
371 371 source_dir)
372 372
373 373 imagerows = ['.. image:: %s'%outfile]
374 374
375 375 for kwarg in saveargs[2:]:
376 376 arg, val = kwarg.split('=')
377 377 arg = arg.strip()
378 378 val = val.strip()
379 379 imagerows.append(' :%s: %s'%(arg, val))
380 380
381 381 image_file = os.path.basename(outfile) # only return file name
382 382 image_directive = '\n'.join(imagerows)
383 383 return image_file, image_directive
384 384
385 385 # Callbacks for each type of token
386 386 def process_input(self, data, input_prompt, lineno):
387 387 """
388 388 Process data block for INPUT token.
389 389
390 390 """
391 391 decorator, input, rest = data
392 392 image_file = None
393 393 image_directive = None
394 394
395 395 is_verbatim = decorator=='@verbatim' or self.is_verbatim
396 396 is_doctest = (decorator is not None and \
397 397 decorator.startswith('@doctest')) or self.is_doctest
398 398 is_suppress = decorator=='@suppress' or self.is_suppress
399 399 is_okexcept = decorator=='@okexcept' or self.is_okexcept
400 400 is_okwarning = decorator=='@okwarning' or self.is_okwarning
401 401 is_savefig = decorator is not None and \
402 402 decorator.startswith('@savefig')
403 403
404 404 input_lines = input.split('\n')
405 405 if len(input_lines) > 1:
406 406 if input_lines[-1] != "":
407 407 input_lines.append('') # make sure there's a blank line
408 408 # so splitter buffer gets reset
409 409
410 410 continuation = ' %s:'%''.join(['.']*(len(str(lineno))+2))
411 411
412 412 if is_savefig:
413 413 image_file, image_directive = self.process_image(decorator)
414 414
415 415 ret = []
416 416 is_semicolon = False
417 417
418 418 # Hold the execution count, if requested to do so.
419 419 if is_suppress and self.hold_count:
420 420 store_history = False
421 421 else:
422 422 store_history = True
423 423
424 424 # Note: catch_warnings is not thread safe
425 425 with warnings.catch_warnings(record=True) as ws:
426 426 for i, line in enumerate(input_lines):
427 427 if line.endswith(';'):
428 428 is_semicolon = True
429 429
430 430 if i == 0:
431 431 # process the first input line
432 432 if is_verbatim:
433 433 self.process_input_line('')
434 434 self.IP.execution_count += 1 # increment it anyway
435 435 else:
436 436 # only submit the line in non-verbatim mode
437 437 self.process_input_line(line, store_history=store_history)
438 438 formatted_line = '%s %s'%(input_prompt, line)
439 439 else:
440 440 # process a continuation line
441 441 if not is_verbatim:
442 442 self.process_input_line(line, store_history=store_history)
443 443
444 444 formatted_line = '%s %s'%(continuation, line)
445 445
446 446 if not is_suppress:
447 447 ret.append(formatted_line)
448 448
449 449 if not is_suppress and len(rest.strip()) and is_verbatim:
450 450 # The "rest" is the standard output of the input. This needs to be
451 451 # added when in verbatim mode. If there is no "rest", then we don't
452 452 # add it, as the new line will be added by the processed output.
453 453 ret.append(rest)
454 454
455 455 # Fetch the processed output. (This is not the submitted output.)
456 456 self.cout.seek(0)
457 457 processed_output = self.cout.read()
458 458 if not is_suppress and not is_semicolon:
459 459 #
460 460 # In IPythonDirective.run, the elements of `ret` are eventually
461 461 # combined such that '' entries correspond to newlines. So if
462 462 # `processed_output` is equal to '', then the adding it to `ret`
463 463 # ensures that there is a blank line between consecutive inputs
464 464 # that have no outputs, as in:
465 465 #
466 466 # In [1]: x = 4
467 467 #
468 468 # In [2]: x = 5
469 469 #
470 470 # When there is processed output, it has a '\n' at the tail end. So
471 471 # adding the output to `ret` will provide the necessary spacing
472 472 # between consecutive input/output blocks, as in:
473 473 #
474 474 # In [1]: x
475 475 # Out[1]: 5
476 476 #
477 477 # In [2]: x
478 478 # Out[2]: 5
479 479 #
480 480 # When there is stdout from the input, it also has a '\n' at the
481 481 # tail end, and so this ensures proper spacing as well. E.g.:
482 482 #
483 483 # In [1]: print x
484 484 # 5
485 485 #
486 486 # In [2]: x = 5
487 487 #
488 488 # When in verbatim mode, `processed_output` is empty (because
489 489 # nothing was passed to IP. Sometimes the submitted code block has
490 490 # an Out[] portion and sometimes it does not. When it does not, we
491 491 # need to ensure proper spacing, so we have to add '' to `ret`.
492 492 # However, if there is an Out[] in the submitted code, then we do
493 493 # not want to add a newline as `process_output` has stuff to add.
494 494 # The difficulty is that `process_input` doesn't know if
495 495 # `process_output` will be called---so it doesn't know if there is
496 496 # Out[] in the code block. The requires that we include a hack in
497 497 # `process_block`. See the comments there.
498 498 #
499 499 ret.append(processed_output)
500 500 elif is_semicolon:
501 501 # Make sure there is a newline after the semicolon.
502 502 ret.append('')
503 503
504 504 # context information
505 505 filename = "Unknown"
506 506 lineno = 0
507 507 if self.directive.state:
508 508 filename = self.directive.state.document.current_source
509 509 lineno = self.directive.state.document.current_line
510 510
511 511 # output any exceptions raised during execution to stdout
512 512 # unless :okexcept: has been specified.
513 513 if not is_okexcept and "Traceback" in processed_output:
514 514 s = "\nException in %s at block ending on line %s\n" % (filename, lineno)
515 515 s += "Specify :okexcept: as an option in the ipython:: block to suppress this message\n"
516 516 sys.stdout.write('\n\n>>>' + ('-' * 73))
517 517 sys.stdout.write(s)
518 518 sys.stdout.write(processed_output)
519 519 sys.stdout.write('<<<' + ('-' * 73) + '\n\n')
520 520
521 521 # output any warning raised during execution to stdout
522 522 # unless :okwarning: has been specified.
523 523 if not is_okwarning:
524 524 for w in ws:
525 525 s = "\nWarning in %s at block ending on line %s\n" % (filename, lineno)
526 526 s += "Specify :okwarning: as an option in the ipython:: block to suppress this message\n"
527 527 sys.stdout.write('\n\n>>>' + ('-' * 73))
528 528 sys.stdout.write(s)
529 529 sys.stdout.write(('-' * 76) + '\n')
530 530 s=warnings.formatwarning(w.message, w.category,
531 531 w.filename, w.lineno, w.line)
532 532 sys.stdout.write(s)
533 533 sys.stdout.write('<<<' + ('-' * 73) + '\n')
534 534
535 535 self.cout.truncate(0)
536 536
537 537 return (ret, input_lines, processed_output,
538 538 is_doctest, decorator, image_file, image_directive)
539 539
540 540
541 541 def process_output(self, data, output_prompt, input_lines, output,
542 542 is_doctest, decorator, image_file):
543 543 """
544 544 Process data block for OUTPUT token.
545 545
546 546 """
547 547 # Recall: `data` is the submitted output, and `output` is the processed
548 548 # output from `input_lines`.
549 549
550 550 TAB = ' ' * 4
551 551
552 552 if is_doctest and output is not None:
553 553
554 554 found = output # This is the processed output
555 555 found = found.strip()
556 556 submitted = data.strip()
557 557
558 558 if self.directive is None:
559 559 source = 'Unavailable'
560 560 content = 'Unavailable'
561 561 else:
562 562 source = self.directive.state.document.current_source
563 563 content = self.directive.content
564 564 # Add tabs and join into a single string.
565 565 content = '\n'.join([TAB + line for line in content])
566 566
567 567 # Make sure the output contains the output prompt.
568 568 ind = found.find(output_prompt)
569 569 if ind < 0:
570 570 e = ('output does not contain output prompt\n\n'
571 571 'Document source: {0}\n\n'
572 572 'Raw content: \n{1}\n\n'
573 573 'Input line(s):\n{TAB}{2}\n\n'
574 574 'Output line(s):\n{TAB}{3}\n\n')
575 575 e = e.format(source, content, '\n'.join(input_lines),
576 576 repr(found), TAB=TAB)
577 577 raise RuntimeError(e)
578 578 found = found[len(output_prompt):].strip()
579 579
580 580 # Handle the actual doctest comparison.
581 581 if decorator.strip() == '@doctest':
582 582 # Standard doctest
583 583 if found != submitted:
584 584 e = ('doctest failure\n\n'
585 585 'Document source: {0}\n\n'
586 586 'Raw content: \n{1}\n\n'
587 587 'On input line(s):\n{TAB}{2}\n\n'
588 588 'we found output:\n{TAB}{3}\n\n'
589 589 'instead of the expected:\n{TAB}{4}\n\n')
590 590 e = e.format(source, content, '\n'.join(input_lines),
591 591 repr(found), repr(submitted), TAB=TAB)
592 592 raise RuntimeError(e)
593 593 else:
594 594 self.custom_doctest(decorator, input_lines, found, submitted)
595 595
596 596 # When in verbatim mode, this holds additional submitted output
597 597 # to be written in the final Sphinx output.
598 598 # https://github.com/ipython/ipython/issues/5776
599 599 out_data = []
600 600
601 601 is_verbatim = decorator=='@verbatim' or self.is_verbatim
602 602 if is_verbatim and data.strip():
603 603 # Note that `ret` in `process_block` has '' as its last element if
604 604 # the code block was in verbatim mode. So if there is no submitted
605 605 # output, then we will have proper spacing only if we do not add
606 606 # an additional '' to `out_data`. This is why we condition on
607 607 # `and data.strip()`.
608 608
609 609 # The submitted output has no output prompt. If we want the
610 610 # prompt and the code to appear, we need to join them now
611 611 # instead of adding them separately---as this would create an
612 612 # undesired newline. How we do this ultimately depends on the
613 613 # format of the output regex. I'll do what works for the default
614 614 # prompt for now, and we might have to adjust if it doesn't work
615 615 # in other cases. Finally, the submitted output does not have
616 616 # a trailing newline, so we must add it manually.
617 617 out_data.append("{0} {1}\n".format(output_prompt, data))
618 618
619 619 return out_data
620 620
621 621 def process_comment(self, data):
622 622 """Process data fPblock for COMMENT token."""
623 623 if not self.is_suppress:
624 624 return [data]
625 625
626 626 def save_image(self, image_file):
627 627 """
628 628 Saves the image file to disk.
629 629 """
630 630 self.ensure_pyplot()
631 631 command = 'plt.gcf().savefig("%s")'%image_file
632 632 #print 'SAVEFIG', command # dbg
633 633 self.process_input_line('bookmark ipy_thisdir', store_history=False)
634 634 self.process_input_line('cd -b ipy_savedir', store_history=False)
635 635 self.process_input_line(command, store_history=False)
636 636 self.process_input_line('cd -b ipy_thisdir', store_history=False)
637 637 self.process_input_line('bookmark -d ipy_thisdir', store_history=False)
638 638 self.clear_cout()
639 639
640 640 def process_block(self, block):
641 641 """
642 642 process block from the block_parser and return a list of processed lines
643 643 """
644 644 ret = []
645 645 output = None
646 646 input_lines = None
647 647 lineno = self.IP.execution_count
648 648
649 649 input_prompt = self.promptin % lineno
650 650 output_prompt = self.promptout % lineno
651 651 image_file = None
652 652 image_directive = None
653 653
654 654 found_input = False
655 655 for token, data in block:
656 656 if token == COMMENT:
657 657 out_data = self.process_comment(data)
658 658 elif token == INPUT:
659 659 found_input = True
660 660 (out_data, input_lines, output, is_doctest,
661 661 decorator, image_file, image_directive) = \
662 662 self.process_input(data, input_prompt, lineno)
663 663 elif token == OUTPUT:
664 664 if not found_input:
665 665
666 666 TAB = ' ' * 4
667 667 linenumber = 0
668 668 source = 'Unavailable'
669 669 content = 'Unavailable'
670 670 if self.directive:
671 671 linenumber = self.directive.state.document.current_line
672 672 source = self.directive.state.document.current_source
673 673 content = self.directive.content
674 674 # Add tabs and join into a single string.
675 675 content = '\n'.join([TAB + line for line in content])
676 676
677 677 e = ('\n\nInvalid block: Block contains an output prompt '
678 678 'without an input prompt.\n\n'
679 679 'Document source: {0}\n\n'
680 680 'Content begins at line {1}: \n\n{2}\n\n'
681 681 'Problematic block within content: \n\n{TAB}{3}\n\n')
682 682 e = e.format(source, linenumber, content, block, TAB=TAB)
683 683
684 684 # Write, rather than include in exception, since Sphinx
685 685 # will truncate tracebacks.
686 686 sys.stdout.write(e)
687 687 raise RuntimeError('An invalid block was detected.')
688 688
689 689 out_data = \
690 690 self.process_output(data, output_prompt, input_lines,
691 691 output, is_doctest, decorator,
692 692 image_file)
693 693 if out_data:
694 694 # Then there was user submitted output in verbatim mode.
695 695 # We need to remove the last element of `ret` that was
696 696 # added in `process_input`, as it is '' and would introduce
697 697 # an undesirable newline.
698 698 assert(ret[-1] == '')
699 699 del ret[-1]
700 700
701 701 if out_data:
702 702 ret.extend(out_data)
703 703
704 704 # save the image files
705 705 if image_file is not None:
706 706 self.save_image(image_file)
707 707
708 708 return ret, image_directive
709 709
710 710 def ensure_pyplot(self):
711 711 """
712 712 Ensures that pyplot has been imported into the embedded IPython shell.
713 713
714 714 Also, makes sure to set the backend appropriately if not set already.
715 715
716 716 """
717 717 # We are here if the @figure pseudo decorator was used. Thus, it's
718 718 # possible that we could be here even if python_mplbackend were set to
719 719 # `None`. That's also strange and perhaps worthy of raising an
720 720 # exception, but for now, we just set the backend to 'agg'.
721 721
722 722 if not self._pyplot_imported:
723 723 if 'matplotlib.backends' not in sys.modules:
724 724 # Then ipython_matplotlib was set to None but there was a
725 725 # call to the @figure decorator (and ipython_execlines did
726 726 # not set a backend).
727 727 #raise Exception("No backend was set, but @figure was used!")
728 728 import matplotlib
729 729 matplotlib.use('agg')
730 730
731 731 # Always import pyplot into embedded shell.
732 732 self.process_input_line('import matplotlib.pyplot as plt',
733 733 store_history=False)
734 734 self._pyplot_imported = True
735 735
736 736 def process_pure_python(self, content):
737 737 """
738 738 content is a list of strings. it is unedited directive content
739 739
740 740 This runs it line by line in the InteractiveShell, prepends
741 741 prompts as needed capturing stderr and stdout, then returns
742 742 the content as a list as if it were ipython code
743 743 """
744 744 output = []
745 745 savefig = False # keep up with this to clear figure
746 746 multiline = False # to handle line continuation
747 747 multiline_start = None
748 748 fmtin = self.promptin
749 749
750 750 ct = 0
751 751
752 752 for lineno, line in enumerate(content):
753 753
754 754 line_stripped = line.strip()
755 755 if not len(line):
756 756 output.append(line)
757 757 continue
758 758
759 759 # handle decorators
760 760 if line_stripped.startswith('@'):
761 761 output.extend([line])
762 762 if 'savefig' in line:
763 763 savefig = True # and need to clear figure
764 764 continue
765 765
766 766 # handle comments
767 767 if line_stripped.startswith('#'):
768 768 output.extend([line])
769 769 continue
770 770
771 771 # deal with lines checking for multiline
772 772 continuation = u' %s:'% ''.join(['.']*(len(str(ct))+2))
773 773 if not multiline:
774 774 modified = u"%s %s" % (fmtin % ct, line_stripped)
775 775 output.append(modified)
776 776 ct += 1
777 777 try:
778 778 ast.parse(line_stripped)
779 779 output.append(u'')
780 780 except Exception: # on a multiline
781 781 multiline = True
782 782 multiline_start = lineno
783 783 else: # still on a multiline
784 784 modified = u'%s %s' % (continuation, line)
785 785 output.append(modified)
786 786
787 787 # if the next line is indented, it should be part of multiline
788 788 if len(content) > lineno + 1:
789 789 nextline = content[lineno + 1]
790 790 if len(nextline) - len(nextline.lstrip()) > 3:
791 791 continue
792 792 try:
793 793 mod = ast.parse(
794 794 '\n'.join(content[multiline_start:lineno+1]))
795 795 if isinstance(mod.body[0], ast.FunctionDef):
796 796 # check to see if we have the whole function
797 797 for element in mod.body[0].body:
798 798 if isinstance(element, ast.Return):
799 799 multiline = False
800 800 else:
801 801 output.append(u'')
802 802 multiline = False
803 803 except Exception:
804 804 pass
805 805
806 806 if savefig: # clear figure if plotted
807 807 self.ensure_pyplot()
808 808 self.process_input_line('plt.clf()', store_history=False)
809 809 self.clear_cout()
810 810 savefig = False
811 811
812 812 return output
813 813
814 814 def custom_doctest(self, decorator, input_lines, found, submitted):
815 815 """
816 816 Perform a specialized doctest.
817 817
818 818 """
819 819 from .custom_doctests import doctests
820 820
821 821 args = decorator.split()
822 822 doctest_type = args[1]
823 823 if doctest_type in doctests:
824 824 doctests[doctest_type](self, args, input_lines, found, submitted)
825 825 else:
826 826 e = "Invalid option to @doctest: {0}".format(doctest_type)
827 827 raise Exception(e)
828 828
829 829
830 830 class IPythonDirective(Directive):
831 831
832 832 has_content = True
833 833 required_arguments = 0
834 834 optional_arguments = 4 # python, suppress, verbatim, doctest
835 835 final_argumuent_whitespace = True
836 836 option_spec = { 'python': directives.unchanged,
837 837 'suppress' : directives.flag,
838 838 'verbatim' : directives.flag,
839 839 'doctest' : directives.flag,
840 840 'okexcept': directives.flag,
841 841 'okwarning': directives.flag
842 842 }
843 843
844 844 shell = None
845 845
846 846 seen_docs = set()
847 847
848 848 def get_config_options(self):
849 849 # contains sphinx configuration variables
850 850 config = self.state.document.settings.env.config
851 851
852 852 # get config variables to set figure output directory
853 853 outdir = self.state.document.settings.env.app.outdir
854 854 savefig_dir = config.ipython_savefig_dir
855 855 source_dir = os.path.dirname(self.state.document.current_source)
856 856 if savefig_dir is None:
857 857 savefig_dir = config.html_static_path or '_static'
858 858 if isinstance(savefig_dir, list):
859 859 savefig_dir = os.path.join(*savefig_dir)
860 860 savefig_dir = os.path.join(outdir, savefig_dir)
861 861
862 862 # get regex and prompt stuff
863 863 rgxin = config.ipython_rgxin
864 864 rgxout = config.ipython_rgxout
865 865 promptin = config.ipython_promptin
866 866 promptout = config.ipython_promptout
867 867 mplbackend = config.ipython_mplbackend
868 868 exec_lines = config.ipython_execlines
869 869 hold_count = config.ipython_holdcount
870 870
871 871 return (savefig_dir, source_dir, rgxin, rgxout,
872 872 promptin, promptout, mplbackend, exec_lines, hold_count)
873 873
874 874 def setup(self):
875 875 # Get configuration values.
876 876 (savefig_dir, source_dir, rgxin, rgxout, promptin, promptout,
877 877 mplbackend, exec_lines, hold_count) = self.get_config_options()
878 878
879 879 if self.shell is None:
880 880 # We will be here many times. However, when the
881 881 # EmbeddedSphinxShell is created, its interactive shell member
882 882 # is the same for each instance.
883 883
884 884 if mplbackend and 'matplotlib.backends' not in sys.modules:
885 885 import matplotlib
886 886 matplotlib.use(mplbackend)
887 887
888 888 # Must be called after (potentially) importing matplotlib and
889 889 # setting its backend since exec_lines might import pylab.
890 890 self.shell = EmbeddedSphinxShell(exec_lines)
891 891
892 892 # Store IPython directive to enable better error messages
893 893 self.shell.directive = self
894 894
895 895 # reset the execution count if we haven't processed this doc
896 896 #NOTE: this may be borked if there are multiple seen_doc tmp files
897 897 #check time stamp?
898 898 if not self.state.document.current_source in self.seen_docs:
899 899 self.shell.IP.history_manager.reset()
900 900 self.shell.IP.execution_count = 1
901 self.shell.IP.prompt_manager.width = 0
902 901 self.seen_docs.add(self.state.document.current_source)
903 902
904 903 # and attach to shell so we don't have to pass them around
905 904 self.shell.rgxin = rgxin
906 905 self.shell.rgxout = rgxout
907 906 self.shell.promptin = promptin
908 907 self.shell.promptout = promptout
909 908 self.shell.savefig_dir = savefig_dir
910 909 self.shell.source_dir = source_dir
911 910 self.shell.hold_count = hold_count
912 911
913 912 # setup bookmark for saving figures directory
914 913 self.shell.process_input_line('bookmark ipy_savedir %s'%savefig_dir,
915 914 store_history=False)
916 915 self.shell.clear_cout()
917 916
918 917 return rgxin, rgxout, promptin, promptout
919 918
920 919 def teardown(self):
921 920 # delete last bookmark
922 921 self.shell.process_input_line('bookmark -d ipy_savedir',
923 922 store_history=False)
924 923 self.shell.clear_cout()
925 924
926 925 def run(self):
927 926 debug = False
928 927
929 928 #TODO, any reason block_parser can't be a method of embeddable shell
930 929 # then we wouldn't have to carry these around
931 930 rgxin, rgxout, promptin, promptout = self.setup()
932 931
933 932 options = self.options
934 933 self.shell.is_suppress = 'suppress' in options
935 934 self.shell.is_doctest = 'doctest' in options
936 935 self.shell.is_verbatim = 'verbatim' in options
937 936 self.shell.is_okexcept = 'okexcept' in options
938 937 self.shell.is_okwarning = 'okwarning' in options
939 938
940 939 # handle pure python code
941 940 if 'python' in self.arguments:
942 941 content = self.content
943 942 self.content = self.shell.process_pure_python(content)
944 943
945 944 # parts consists of all text within the ipython-block.
946 945 # Each part is an input/output block.
947 946 parts = '\n'.join(self.content).split('\n\n')
948 947
949 948 lines = ['.. code-block:: ipython', '']
950 949 figures = []
951 950
952 951 for part in parts:
953 952 block = block_parser(part, rgxin, rgxout, promptin, promptout)
954 953 if len(block):
955 954 rows, figure = self.shell.process_block(block)
956 955 for row in rows:
957 956 lines.extend([' {0}'.format(line)
958 957 for line in row.split('\n')])
959 958
960 959 if figure is not None:
961 960 figures.append(figure)
962 961
963 962 for figure in figures:
964 963 lines.append('')
965 964 lines.extend(figure.split('\n'))
966 965 lines.append('')
967 966
968 967 if len(lines) > 2:
969 968 if debug:
970 969 print('\n'.join(lines))
971 970 else:
972 971 # This has to do with input, not output. But if we comment
973 972 # these lines out, then no IPython code will appear in the
974 973 # final output.
975 974 self.state_machine.insert_input(
976 975 lines, self.state_machine.input_lines.source(0))
977 976
978 977 # cleanup
979 978 self.teardown()
980 979
981 980 return []
982 981
983 982 # Enable as a proper Sphinx directive
984 983 def setup(app):
985 984 setup.app = app
986 985
987 986 app.add_directive('ipython', IPythonDirective)
988 987 app.add_config_value('ipython_savefig_dir', None, 'env')
989 988 app.add_config_value('ipython_rgxin',
990 989 re.compile('In \[(\d+)\]:\s?(.*)\s*'), 'env')
991 990 app.add_config_value('ipython_rgxout',
992 991 re.compile('Out\[(\d+)\]:\s?(.*)\s*'), 'env')
993 992 app.add_config_value('ipython_promptin', 'In [%d]:', 'env')
994 993 app.add_config_value('ipython_promptout', 'Out[%d]:', 'env')
995 994
996 995 # We could just let matplotlib pick whatever is specified as the default
997 996 # backend in the matplotlibrc file, but this would cause issues if the
998 997 # backend didn't work in headless environments. For this reason, 'agg'
999 998 # is a good default backend choice.
1000 999 app.add_config_value('ipython_mplbackend', 'agg', 'env')
1001 1000
1002 1001 # If the user sets this config value to `None`, then EmbeddedSphinxShell's
1003 1002 # __init__ method will treat it as [].
1004 1003 execlines = ['import numpy as np', 'import matplotlib.pyplot as plt']
1005 1004 app.add_config_value('ipython_execlines', execlines, 'env')
1006 1005
1007 1006 app.add_config_value('ipython_holdcount', True, 'env')
1008 1007
1009 1008 metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
1010 1009 return metadata
1011 1010
1012 1011 # Simple smoke test, needs to be converted to a proper automatic test.
1013 1012 def test():
1014 1013
1015 1014 examples = [
1016 1015 r"""
1017 1016 In [9]: pwd
1018 1017 Out[9]: '/home/jdhunter/py4science/book'
1019 1018
1020 1019 In [10]: cd bookdata/
1021 1020 /home/jdhunter/py4science/book/bookdata
1022 1021
1023 1022 In [2]: from pylab import *
1024 1023
1025 1024 In [2]: ion()
1026 1025
1027 1026 In [3]: im = imread('stinkbug.png')
1028 1027
1029 1028 @savefig mystinkbug.png width=4in
1030 1029 In [4]: imshow(im)
1031 1030 Out[4]: <matplotlib.image.AxesImage object at 0x39ea850>
1032 1031
1033 1032 """,
1034 1033 r"""
1035 1034
1036 1035 In [1]: x = 'hello world'
1037 1036
1038 1037 # string methods can be
1039 1038 # used to alter the string
1040 1039 @doctest
1041 1040 In [2]: x.upper()
1042 1041 Out[2]: 'HELLO WORLD'
1043 1042
1044 1043 @verbatim
1045 1044 In [3]: x.st<TAB>
1046 1045 x.startswith x.strip
1047 1046 """,
1048 1047 r"""
1049 1048
1050 1049 In [130]: url = 'http://ichart.finance.yahoo.com/table.csv?s=CROX\
1051 1050 .....: &d=9&e=22&f=2009&g=d&a=1&br=8&c=2006&ignore=.csv'
1052 1051
1053 1052 In [131]: print url.split('&')
1054 1053 ['http://ichart.finance.yahoo.com/table.csv?s=CROX', 'd=9', 'e=22', 'f=2009', 'g=d', 'a=1', 'b=8', 'c=2006', 'ignore=.csv']
1055 1054
1056 1055 In [60]: import urllib
1057 1056
1058 1057 """,
1059 1058 r"""\
1060 1059
1061 1060 In [133]: import numpy.random
1062 1061
1063 1062 @suppress
1064 1063 In [134]: numpy.random.seed(2358)
1065 1064
1066 1065 @doctest
1067 1066 In [135]: numpy.random.rand(10,2)
1068 1067 Out[135]:
1069 1068 array([[ 0.64524308, 0.59943846],
1070 1069 [ 0.47102322, 0.8715456 ],
1071 1070 [ 0.29370834, 0.74776844],
1072 1071 [ 0.99539577, 0.1313423 ],
1073 1072 [ 0.16250302, 0.21103583],
1074 1073 [ 0.81626524, 0.1312433 ],
1075 1074 [ 0.67338089, 0.72302393],
1076 1075 [ 0.7566368 , 0.07033696],
1077 1076 [ 0.22591016, 0.77731835],
1078 1077 [ 0.0072729 , 0.34273127]])
1079 1078
1080 1079 """,
1081 1080
1082 1081 r"""
1083 1082 In [106]: print x
1084 1083 jdh
1085 1084
1086 1085 In [109]: for i in range(10):
1087 1086 .....: print i
1088 1087 .....:
1089 1088 .....:
1090 1089 0
1091 1090 1
1092 1091 2
1093 1092 3
1094 1093 4
1095 1094 5
1096 1095 6
1097 1096 7
1098 1097 8
1099 1098 9
1100 1099 """,
1101 1100
1102 1101 r"""
1103 1102
1104 1103 In [144]: from pylab import *
1105 1104
1106 1105 In [145]: ion()
1107 1106
1108 1107 # use a semicolon to suppress the output
1109 1108 @savefig test_hist.png width=4in
1110 1109 In [151]: hist(np.random.randn(10000), 100);
1111 1110
1112 1111
1113 1112 @savefig test_plot.png width=4in
1114 1113 In [151]: plot(np.random.randn(10000), 'o');
1115 1114 """,
1116 1115
1117 1116 r"""
1118 1117 # use a semicolon to suppress the output
1119 1118 In [151]: plt.clf()
1120 1119
1121 1120 @savefig plot_simple.png width=4in
1122 1121 In [151]: plot([1,2,3])
1123 1122
1124 1123 @savefig hist_simple.png width=4in
1125 1124 In [151]: hist(np.random.randn(10000), 100);
1126 1125
1127 1126 """,
1128 1127 r"""
1129 1128 # update the current fig
1130 1129 In [151]: ylabel('number')
1131 1130
1132 1131 In [152]: title('normal distribution')
1133 1132
1134 1133
1135 1134 @savefig hist_with_text.png
1136 1135 In [153]: grid(True)
1137 1136
1138 1137 @doctest float
1139 1138 In [154]: 0.1 + 0.2
1140 1139 Out[154]: 0.3
1141 1140
1142 1141 @doctest float
1143 1142 In [155]: np.arange(16).reshape(4,4)
1144 1143 Out[155]:
1145 1144 array([[ 0, 1, 2, 3],
1146 1145 [ 4, 5, 6, 7],
1147 1146 [ 8, 9, 10, 11],
1148 1147 [12, 13, 14, 15]])
1149 1148
1150 1149 In [1]: x = np.arange(16, dtype=float).reshape(4,4)
1151 1150
1152 1151 In [2]: x[0,0] = np.inf
1153 1152
1154 1153 In [3]: x[0,1] = np.nan
1155 1154
1156 1155 @doctest float
1157 1156 In [4]: x
1158 1157 Out[4]:
1159 1158 array([[ inf, nan, 2., 3.],
1160 1159 [ 4., 5., 6., 7.],
1161 1160 [ 8., 9., 10., 11.],
1162 1161 [ 12., 13., 14., 15.]])
1163 1162
1164 1163
1165 1164 """,
1166 1165 ]
1167 1166 # skip local-file depending first example:
1168 1167 examples = examples[1:]
1169 1168
1170 1169 #ipython_directive.DEBUG = True # dbg
1171 1170 #options = dict(suppress=True) # dbg
1172 1171 options = dict()
1173 1172 for example in examples:
1174 1173 content = example.split('\n')
1175 1174 IPythonDirective('debug', arguments=None, options=options,
1176 1175 content=content, lineno=0,
1177 1176 content_offset=None, block_text=None,
1178 1177 state=None, state_machine=None,
1179 1178 )
1180 1179
1181 1180 # Run test suite as a script
1182 1181 if __name__=='__main__':
1183 1182 if not os.path.isdir('_static'):
1184 1183 os.mkdir('_static')
1185 1184 test()
1186 1185 print('All OK? Check figures in _static/')
@@ -1,810 +1,810 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Subclass of InteractiveShell for terminal based frontends."""
3 3
4 4 # Copyright (c) IPython Development Team.
5 5 # Distributed under the terms of the Modified BSD License.
6 6
7 7 from __future__ import print_function
8 8
9 9 import bdb
10 10 import os
11 11 import sys
12 12
13 13 from IPython.core.error import TryNext, UsageError
14 14 from IPython.core.usage import interactive_usage
15 15 from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC
16 16 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
17 17 from IPython.core.magic import Magics, magics_class, line_magic
18 18 from IPython.lib.clipboard import ClipboardEmpty
19 19 from IPython.utils.contexts import NoOpContext
20 20 from IPython.utils.decorators import undoc
21 21 from IPython.utils.encoding import get_stream_enc
22 22 from IPython.utils import py3compat
23 23 from IPython.utils.terminal import toggle_set_term_title, set_term_title
24 24 from IPython.utils.process import abbrev_cwd
25 25 from warnings import warn
26 26 from logging import error
27 27 from IPython.utils.text import num_ini_spaces, SList, strip_email_quotes
28 28 from traitlets import Integer, CBool, Unicode
29 29
30 30
31 31 def get_default_editor():
32 32 try:
33 33 ed = os.environ['EDITOR']
34 34 if not py3compat.PY3:
35 35 ed = ed.decode()
36 36 return ed
37 37 except KeyError:
38 38 pass
39 39 except UnicodeError:
40 40 warn("$EDITOR environment variable is not pure ASCII. Using platform "
41 41 "default editor.")
42 42
43 43 if os.name == 'posix':
44 44 return 'vi' # the only one guaranteed to be there!
45 45 else:
46 46 return 'notepad' # same in Windows!
47 47
48 48 def get_pasted_lines(sentinel, l_input=py3compat.input, quiet=False):
49 49 """ Yield pasted lines until the user enters the given sentinel value.
50 50 """
51 51 if not quiet:
52 52 print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
53 53 % sentinel)
54 54 prompt = ":"
55 55 else:
56 56 prompt = ""
57 57 while True:
58 58 try:
59 59 l = py3compat.str_to_unicode(l_input(prompt))
60 60 if l == sentinel:
61 61 return
62 62 else:
63 63 yield l
64 64 except EOFError:
65 65 print('<EOF>')
66 66 return
67 67
68 68 @undoc
69 69 def no_op(*a, **kw): pass
70 70
71 71
72 72 class ReadlineNoRecord(object):
73 73 """Context manager to execute some code, then reload readline history
74 74 so that interactive input to the code doesn't appear when pressing up."""
75 75 def __init__(self, shell):
76 76 self.shell = shell
77 77 self._nested_level = 0
78 78
79 79 def __enter__(self):
80 80 if self._nested_level == 0:
81 81 try:
82 82 self.orig_length = self.current_length()
83 83 self.readline_tail = self.get_readline_tail()
84 84 except (AttributeError, IndexError): # Can fail with pyreadline
85 85 self.orig_length, self.readline_tail = 999999, []
86 86 self._nested_level += 1
87 87
88 88 def __exit__(self, type, value, traceback):
89 89 self._nested_level -= 1
90 90 if self._nested_level == 0:
91 91 # Try clipping the end if it's got longer
92 92 try:
93 93 e = self.current_length() - self.orig_length
94 94 if e > 0:
95 95 for _ in range(e):
96 96 self.shell.readline.remove_history_item(self.orig_length)
97 97
98 98 # If it still doesn't match, just reload readline history.
99 99 if self.current_length() != self.orig_length \
100 100 or self.get_readline_tail() != self.readline_tail:
101 101 self.shell.refill_readline_hist()
102 102 except (AttributeError, IndexError):
103 103 pass
104 104 # Returning False will cause exceptions to propagate
105 105 return False
106 106
107 107 def current_length(self):
108 108 return self.shell.readline.get_current_history_length()
109 109
110 110 def get_readline_tail(self, n=10):
111 111 """Get the last n items in readline history."""
112 112 end = self.shell.readline.get_current_history_length() + 1
113 113 start = max(end-n, 1)
114 114 ghi = self.shell.readline.get_history_item
115 115 return [ghi(x) for x in range(start, end)]
116 116
117 117
118 118 @magics_class
119 119 class TerminalMagics(Magics):
120 120 def __init__(self, shell):
121 121 super(TerminalMagics, self).__init__(shell)
122 122 self.input_splitter = IPythonInputSplitter()
123 123
124 124 def store_or_execute(self, block, name):
125 125 """ Execute a block, or store it in a variable, per the user's request.
126 126 """
127 127 if name:
128 128 # If storing it for further editing
129 129 self.shell.user_ns[name] = SList(block.splitlines())
130 130 print("Block assigned to '%s'" % name)
131 131 else:
132 132 b = self.preclean_input(block)
133 133 self.shell.user_ns['pasted_block'] = b
134 134 self.shell.using_paste_magics = True
135 135 try:
136 136 self.shell.run_cell(b)
137 137 finally:
138 138 self.shell.using_paste_magics = False
139 139
140 140 def preclean_input(self, block):
141 141 lines = block.splitlines()
142 142 while lines and not lines[0].strip():
143 143 lines = lines[1:]
144 144 return strip_email_quotes('\n'.join(lines))
145 145
146 146 def rerun_pasted(self, name='pasted_block'):
147 147 """ Rerun a previously pasted command.
148 148 """
149 149 b = self.shell.user_ns.get(name)
150 150
151 151 # Sanity checks
152 152 if b is None:
153 153 raise UsageError('No previous pasted block available')
154 154 if not isinstance(b, py3compat.string_types):
155 155 raise UsageError(
156 156 "Variable 'pasted_block' is not a string, can't execute")
157 157
158 158 print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
159 159 self.shell.run_cell(b)
160 160
161 161 @line_magic
162 162 def autoindent(self, parameter_s = ''):
163 163 """Toggle autoindent on/off (if available)."""
164 164
165 165 self.shell.set_autoindent()
166 166 print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
167 167
168 168 @line_magic
169 169 def cpaste(self, parameter_s=''):
170 170 """Paste & execute a pre-formatted code block from clipboard.
171 171
172 172 You must terminate the block with '--' (two minus-signs) or Ctrl-D
173 173 alone on the line. You can also provide your own sentinel with '%paste
174 174 -s %%' ('%%' is the new sentinel for this operation).
175 175
176 176 The block is dedented prior to execution to enable execution of method
177 177 definitions. '>' and '+' characters at the beginning of a line are
178 178 ignored, to allow pasting directly from e-mails, diff files and
179 179 doctests (the '...' continuation prompt is also stripped). The
180 180 executed block is also assigned to variable named 'pasted_block' for
181 181 later editing with '%edit pasted_block'.
182 182
183 183 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
184 184 This assigns the pasted block to variable 'foo' as string, without
185 185 dedenting or executing it (preceding >>> and + is still stripped)
186 186
187 187 '%cpaste -r' re-executes the block previously entered by cpaste.
188 188 '%cpaste -q' suppresses any additional output messages.
189 189
190 190 Do not be alarmed by garbled output on Windows (it's a readline bug).
191 191 Just press enter and type -- (and press enter again) and the block
192 192 will be what was just pasted.
193 193
194 194 IPython statements (magics, shell escapes) are not supported (yet).
195 195
196 196 See also
197 197 --------
198 198 paste: automatically pull code from clipboard.
199 199
200 200 Examples
201 201 --------
202 202 ::
203 203
204 204 In [8]: %cpaste
205 205 Pasting code; enter '--' alone on the line to stop.
206 206 :>>> a = ["world!", "Hello"]
207 207 :>>> print " ".join(sorted(a))
208 208 :--
209 209 Hello world!
210 210 """
211 211 opts, name = self.parse_options(parameter_s, 'rqs:', mode='string')
212 212 if 'r' in opts:
213 213 self.rerun_pasted()
214 214 return
215 215
216 216 quiet = ('q' in opts)
217 217
218 218 sentinel = opts.get('s', u'--')
219 219 block = '\n'.join(get_pasted_lines(sentinel, quiet=quiet))
220 220 self.store_or_execute(block, name)
221 221
222 222 @line_magic
223 223 def paste(self, parameter_s=''):
224 224 """Paste & execute a pre-formatted code block from clipboard.
225 225
226 226 The text is pulled directly from the clipboard without user
227 227 intervention and printed back on the screen before execution (unless
228 228 the -q flag is given to force quiet mode).
229 229
230 230 The block is dedented prior to execution to enable execution of method
231 231 definitions. '>' and '+' characters at the beginning of a line are
232 232 ignored, to allow pasting directly from e-mails, diff files and
233 233 doctests (the '...' continuation prompt is also stripped). The
234 234 executed block is also assigned to variable named 'pasted_block' for
235 235 later editing with '%edit pasted_block'.
236 236
237 237 You can also pass a variable name as an argument, e.g. '%paste foo'.
238 238 This assigns the pasted block to variable 'foo' as string, without
239 239 executing it (preceding >>> and + is still stripped).
240 240
241 241 Options:
242 242
243 243 -r: re-executes the block previously entered by cpaste.
244 244
245 245 -q: quiet mode: do not echo the pasted text back to the terminal.
246 246
247 247 IPython statements (magics, shell escapes) are not supported (yet).
248 248
249 249 See also
250 250 --------
251 251 cpaste: manually paste code into terminal until you mark its end.
252 252 """
253 253 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
254 254 if 'r' in opts:
255 255 self.rerun_pasted()
256 256 return
257 257 try:
258 258 block = self.shell.hooks.clipboard_get()
259 259 except TryNext as clipboard_exc:
260 260 message = getattr(clipboard_exc, 'args')
261 261 if message:
262 262 error(message[0])
263 263 else:
264 264 error('Could not get text from the clipboard.')
265 265 return
266 266 except ClipboardEmpty:
267 267 raise UsageError("The clipboard appears to be empty")
268 268
269 269 # By default, echo back to terminal unless quiet mode is requested
270 270 if 'q' not in opts:
271 271 write = self.shell.write
272 272 write(self.shell.pycolorize(block))
273 273 if not block.endswith('\n'):
274 274 write('\n')
275 275 write("## -- End pasted text --\n")
276 276
277 277 self.store_or_execute(block, name)
278 278
279 279 # Class-level: add a '%cls' magic only on Windows
280 280 if sys.platform == 'win32':
281 281 @line_magic
282 282 def cls(self, s):
283 283 """Clear screen.
284 284 """
285 285 os.system("cls")
286 286
287 287
288 288 class TerminalInteractiveShell(InteractiveShell):
289 289
290 290 autoedit_syntax = CBool(False, config=True,
291 291 help="auto editing of files with syntax errors.")
292 292 confirm_exit = CBool(True, config=True,
293 293 help="""
294 294 Set to confirm when you try to exit IPython with an EOF (Control-D
295 295 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
296 296 you can force a direct exit without any confirmation.""",
297 297 )
298 298 # This display_banner only controls whether or not self.show_banner()
299 299 # is called when mainloop/interact are called. The default is False
300 300 # because for the terminal based application, the banner behavior
301 301 # is controlled by the application.
302 302 display_banner = CBool(False) # This isn't configurable!
303 303 embedded = CBool(False)
304 304 embedded_active = CBool(False)
305 305 editor = Unicode(get_default_editor(), config=True,
306 306 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
307 307 )
308 308 pager = Unicode('less', config=True,
309 309 help="The shell program to be used for paging.")
310 310
311 311 screen_length = Integer(0, config=True,
312 312 help=
313 313 """Number of lines of your screen, used to control printing of very
314 314 long strings. Strings longer than this number of lines will be sent
315 315 through a pager instead of directly printed. The default value for
316 316 this is 0, which means IPython will auto-detect your screen size every
317 317 time it needs to print certain potentially long strings (this doesn't
318 318 change the behavior of the 'print' keyword, it's only triggered
319 319 internally). If for some reason this isn't working well (it needs
320 320 curses support), specify it yourself. Otherwise don't change the
321 321 default.""",
322 322 )
323 323 term_title = CBool(False, config=True,
324 324 help="Enable auto setting the terminal title."
325 325 )
326 326 usage = Unicode(interactive_usage)
327 327
328 328 # This `using_paste_magics` is used to detect whether the code is being
329 329 # executed via paste magics functions
330 330 using_paste_magics = CBool(False)
331 331
332 332 # In the terminal, GUI control is done via PyOS_InputHook
333 333 @staticmethod
334 334 def enable_gui(gui=None, app=None):
335 335 """Switch amongst GUI input hooks by name.
336 336 """
337 337 # Deferred import
338 338 from IPython.lib.inputhook import enable_gui as real_enable_gui
339 339 try:
340 340 return real_enable_gui(gui, app)
341 341 except ValueError as e:
342 342 raise UsageError("%s" % e)
343 343
344 344 system = InteractiveShell.system_raw
345 345
346 346 #-------------------------------------------------------------------------
347 347 # Overrides of init stages
348 348 #-------------------------------------------------------------------------
349 349
350 350 def init_display_formatter(self):
351 351 super(TerminalInteractiveShell, self).init_display_formatter()
352 352 # terminal only supports plaintext
353 353 self.display_formatter.active_types = ['text/plain']
354 354
355 355 #-------------------------------------------------------------------------
356 356 # Things related to readline
357 357 #-------------------------------------------------------------------------
358 358
359 359 def init_readline(self):
360 360 """Command history completion/saving/reloading."""
361 361
362 362 if self.readline_use:
363 363 import IPython.utils.rlineimpl as readline
364 364
365 365 self.rl_next_input = None
366 366 self.rl_do_indent = False
367 367
368 368 if not self.readline_use or not readline.have_readline:
369 369 self.readline = None
370 370 # Set a number of methods that depend on readline to be no-op
371 371 self.readline_no_record = NoOpContext()
372 372 self.set_readline_completer = no_op
373 373 self.set_custom_completer = no_op
374 374 if self.readline_use:
375 375 warn('Readline services not available or not loaded.')
376 376 else:
377 377 self.has_readline = True
378 378 self.readline = readline
379 379 sys.modules['readline'] = readline
380 380
381 381 # Platform-specific configuration
382 382 if os.name == 'nt':
383 383 # FIXME - check with Frederick to see if we can harmonize
384 384 # naming conventions with pyreadline to avoid this
385 385 # platform-dependent check
386 386 self.readline_startup_hook = readline.set_pre_input_hook
387 387 else:
388 388 self.readline_startup_hook = readline.set_startup_hook
389 389
390 390 # Readline config order:
391 391 # - IPython config (default value)
392 392 # - custom inputrc
393 393 # - IPython config (user customized)
394 394
395 395 # load IPython config before inputrc if default
396 396 # skip if libedit because parse_and_bind syntax is different
397 397 if not self._custom_readline_config and not readline.uses_libedit:
398 398 for rlcommand in self.readline_parse_and_bind:
399 399 readline.parse_and_bind(rlcommand)
400 400
401 401 # Load user's initrc file (readline config)
402 402 # Or if libedit is used, load editrc.
403 403 inputrc_name = os.environ.get('INPUTRC')
404 404 if inputrc_name is None:
405 405 inputrc_name = '.inputrc'
406 406 if readline.uses_libedit:
407 407 inputrc_name = '.editrc'
408 408 inputrc_name = os.path.join(self.home_dir, inputrc_name)
409 409 if os.path.isfile(inputrc_name):
410 410 try:
411 411 readline.read_init_file(inputrc_name)
412 412 except:
413 413 warn('Problems reading readline initialization file <%s>'
414 414 % inputrc_name)
415 415
416 416 # load IPython config after inputrc if user has customized
417 417 if self._custom_readline_config:
418 418 for rlcommand in self.readline_parse_and_bind:
419 419 readline.parse_and_bind(rlcommand)
420 420
421 421 # Remove some chars from the delimiters list. If we encounter
422 422 # unicode chars, discard them.
423 423 delims = readline.get_completer_delims()
424 424 if not py3compat.PY3:
425 425 delims = delims.encode("ascii", "ignore")
426 426 for d in self.readline_remove_delims:
427 427 delims = delims.replace(d, "")
428 428 delims = delims.replace(ESC_MAGIC, '')
429 429 readline.set_completer_delims(delims)
430 430 # Store these so we can restore them if something like rpy2 modifies
431 431 # them.
432 432 self.readline_delims = delims
433 433 # otherwise we end up with a monster history after a while:
434 434 readline.set_history_length(self.history_length)
435 435
436 436 self.refill_readline_hist()
437 437 self.readline_no_record = ReadlineNoRecord(self)
438 438
439 439 # Configure auto-indent for all platforms
440 440 self.set_autoindent(self.autoindent)
441 441
442 442 def init_completer(self):
443 443 super(TerminalInteractiveShell, self).init_completer()
444 444
445 445 # Only configure readline if we truly are using readline.
446 446 if self.has_readline:
447 447 self.set_readline_completer()
448 448
449 449 def set_readline_completer(self):
450 450 """Reset readline's completer to be our own."""
451 451 self.readline.set_completer(self.Completer.rlcomplete)
452 452
453 453
454 454 def pre_readline(self):
455 455 """readline hook to be used at the start of each line.
456 456
457 457 It handles auto-indent and text from set_next_input."""
458 458
459 459 if self.rl_do_indent:
460 460 self.readline.insert_text(self._indent_current_str())
461 461 if self.rl_next_input is not None:
462 462 self.readline.insert_text(self.rl_next_input)
463 463 self.rl_next_input = None
464 464
465 465 def refill_readline_hist(self):
466 466 # Load the last 1000 lines from history
467 467 self.readline.clear_history()
468 468 stdin_encoding = sys.stdin.encoding or "utf-8"
469 469 last_cell = u""
470 470 for _, _, cell in self.history_manager.get_tail(self.history_load_length,
471 471 include_latest=True):
472 472 # Ignore blank lines and consecutive duplicates
473 473 cell = cell.rstrip()
474 474 if cell and (cell != last_cell):
475 475 try:
476 476 if self.multiline_history:
477 477 self.readline.add_history(py3compat.unicode_to_str(cell,
478 478 stdin_encoding))
479 479 else:
480 480 for line in cell.splitlines():
481 481 self.readline.add_history(py3compat.unicode_to_str(line,
482 482 stdin_encoding))
483 483 last_cell = cell
484 484
485 485 except (TypeError, ValueError) as e:
486 486 # The history DB can get corrupted so it returns strings
487 487 # containing null bytes, which readline objects to.
488 488 warn(("Failed to add string to readline history.\n"
489 489 "Error: {}\n"
490 490 "Cell: {!r}").format(e, cell))
491 491
492 492 #-------------------------------------------------------------------------
493 493 # Things related to the terminal
494 494 #-------------------------------------------------------------------------
495 495
496 496 @property
497 497 def usable_screen_length(self):
498 498 if self.screen_length == 0:
499 499 return 0
500 500 else:
501 501 num_lines_bot = self.separate_in.count('\n')+1
502 502 return self.screen_length - num_lines_bot
503 503
504 504 def _term_title_changed(self, name, new_value):
505 505 self.init_term_title()
506 506
507 507 def init_term_title(self):
508 508 # Enable or disable the terminal title.
509 509 if self.term_title:
510 510 toggle_set_term_title(True)
511 511 set_term_title('IPython: ' + abbrev_cwd())
512 512 else:
513 513 toggle_set_term_title(False)
514 514
515 515 #-------------------------------------------------------------------------
516 516 # Things related to aliases
517 517 #-------------------------------------------------------------------------
518 518
519 519 def init_alias(self):
520 520 # The parent class defines aliases that can be safely used with any
521 521 # frontend.
522 522 super(TerminalInteractiveShell, self).init_alias()
523 523
524 524 # Now define aliases that only make sense on the terminal, because they
525 525 # need direct access to the console in a way that we can't emulate in
526 526 # GUI or web frontend
527 527 if os.name == 'posix':
528 528 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
529 529 ('man', 'man')]
530 530 else :
531 531 aliases = []
532 532
533 533 for name, cmd in aliases:
534 534 self.alias_manager.soft_define_alias(name, cmd)
535 535
536 536 #-------------------------------------------------------------------------
537 537 # Mainloop and code execution logic
538 538 #-------------------------------------------------------------------------
539 539
540 540 def mainloop(self, display_banner=None):
541 541 """Start the mainloop.
542 542
543 543 If an optional banner argument is given, it will override the
544 544 internally created default banner.
545 545 """
546 546
547 547 with self.builtin_trap, self.display_trap:
548 548
549 549 while 1:
550 550 try:
551 551 self.interact(display_banner=display_banner)
552 552 #self.interact_with_readline()
553 553 # XXX for testing of a readline-decoupled repl loop, call
554 554 # interact_with_readline above
555 555 break
556 556 except KeyboardInterrupt:
557 557 # this should not be necessary, but KeyboardInterrupt
558 558 # handling seems rather unpredictable...
559 559 self.write("\nKeyboardInterrupt in interact()\n")
560 560
561 561 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
562 562 """Store multiple lines as a single entry in history"""
563 563
564 564 # do nothing without readline or disabled multiline
565 565 if not self.has_readline or not self.multiline_history:
566 566 return hlen_before_cell
567 567
568 568 # windows rl has no remove_history_item
569 569 if not hasattr(self.readline, "remove_history_item"):
570 570 return hlen_before_cell
571 571
572 572 # skip empty cells
573 573 if not source_raw.rstrip():
574 574 return hlen_before_cell
575 575
576 576 # nothing changed do nothing, e.g. when rl removes consecutive dups
577 577 hlen = self.readline.get_current_history_length()
578 578 if hlen == hlen_before_cell:
579 579 return hlen_before_cell
580 580
581 581 for i in range(hlen - hlen_before_cell):
582 582 self.readline.remove_history_item(hlen - i - 1)
583 583 stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
584 584 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
585 585 stdin_encoding))
586 586 return self.readline.get_current_history_length()
587 587
588 588 def interact(self, display_banner=None):
589 589 """Closely emulate the interactive Python console."""
590 590
591 591 # batch run -> do not interact
592 592 if self.exit_now:
593 593 return
594 594
595 595 if display_banner is None:
596 596 display_banner = self.display_banner
597 597
598 598 if isinstance(display_banner, py3compat.string_types):
599 599 self.show_banner(display_banner)
600 600 elif display_banner:
601 601 self.show_banner()
602 602
603 603 more = False
604 604
605 605 if self.has_readline:
606 606 self.readline_startup_hook(self.pre_readline)
607 607 hlen_b4_cell = self.readline.get_current_history_length()
608 608 else:
609 609 hlen_b4_cell = 0
610 610 # exit_now is set by a call to %Exit or %Quit, through the
611 611 # ask_exit callback.
612 612
613 613 while not self.exit_now:
614 614 self.hooks.pre_prompt_hook()
615 615 if more:
616 616 try:
617 prompt = self.prompt_manager.render('in2')
617 prompt = ' ...: '
618 618 except:
619 619 self.showtraceback()
620 620 if self.autoindent:
621 621 self.rl_do_indent = True
622 622
623 623 else:
624 624 try:
625 prompt = self.separate_in + self.prompt_manager.render('in')
625 prompt = self.separate_in + 'In [{}]: '.format(self.execution_count)
626 626 except:
627 627 self.showtraceback()
628 628 try:
629 629 line = self.raw_input(prompt)
630 630 if self.exit_now:
631 631 # quick exit on sys.std[in|out] close
632 632 break
633 633 if self.autoindent:
634 634 self.rl_do_indent = False
635 635
636 636 except KeyboardInterrupt:
637 637 #double-guard against keyboardinterrupts during kbdint handling
638 638 try:
639 639 self.write('\n' + self.get_exception_only())
640 640 source_raw = self.input_splitter.raw_reset()
641 641 hlen_b4_cell = \
642 642 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
643 643 more = False
644 644 except KeyboardInterrupt:
645 645 pass
646 646 except EOFError:
647 647 if self.autoindent:
648 648 self.rl_do_indent = False
649 649 if self.has_readline:
650 650 self.readline_startup_hook(None)
651 651 self.write('\n')
652 652 self.exit()
653 653 except bdb.BdbQuit:
654 654 warn('The Python debugger has exited with a BdbQuit exception.\n'
655 655 'Because of how pdb handles the stack, it is impossible\n'
656 656 'for IPython to properly format this particular exception.\n'
657 657 'IPython will resume normal operation.')
658 658 except:
659 659 # exceptions here are VERY RARE, but they can be triggered
660 660 # asynchronously by signal handlers, for example.
661 661 self.showtraceback()
662 662 else:
663 663 try:
664 664 self.input_splitter.push(line)
665 665 more = self.input_splitter.push_accepts_more()
666 666 except SyntaxError:
667 667 # Run the code directly - run_cell takes care of displaying
668 668 # the exception.
669 669 more = False
670 670 if (self.SyntaxTB.last_syntax_error and
671 671 self.autoedit_syntax):
672 672 self.edit_syntax_error()
673 673 if not more:
674 674 source_raw = self.input_splitter.raw_reset()
675 675 self.run_cell(source_raw, store_history=True)
676 676 hlen_b4_cell = \
677 677 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
678 678
679 679 # Turn off the exit flag, so the mainloop can be restarted if desired
680 680 self.exit_now = False
681 681
682 682 def raw_input(self, prompt=''):
683 683 """Write a prompt and read a line.
684 684
685 685 The returned line does not include the trailing newline.
686 686 When the user enters the EOF key sequence, EOFError is raised.
687 687
688 688 Parameters
689 689 ----------
690 690
691 691 prompt : str, optional
692 692 A string to be printed to prompt the user.
693 693 """
694 694 # raw_input expects str, but we pass it unicode sometimes
695 695 prompt = py3compat.cast_bytes_py2(prompt)
696 696
697 697 try:
698 698 line = py3compat.cast_unicode_py2(self.raw_input_original(prompt))
699 699 except ValueError:
700 700 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
701 701 " or sys.stdout.close()!\nExiting IPython!\n")
702 702 self.ask_exit()
703 703 return ""
704 704
705 705 # Try to be reasonably smart about not re-indenting pasted input more
706 706 # than necessary. We do this by trimming out the auto-indent initial
707 707 # spaces, if the user's actual input started itself with whitespace.
708 708 if self.autoindent:
709 709 if num_ini_spaces(line) > self.indent_current_nsp:
710 710 line = line[self.indent_current_nsp:]
711 711 self.indent_current_nsp = 0
712 712
713 713 return line
714 714
715 715 #-------------------------------------------------------------------------
716 716 # Methods to support auto-editing of SyntaxErrors.
717 717 #-------------------------------------------------------------------------
718 718
719 719 def edit_syntax_error(self):
720 720 """The bottom half of the syntax error handler called in the main loop.
721 721
722 722 Loop until syntax error is fixed or user cancels.
723 723 """
724 724
725 725 while self.SyntaxTB.last_syntax_error:
726 726 # copy and clear last_syntax_error
727 727 err = self.SyntaxTB.clear_err_state()
728 728 if not self._should_recompile(err):
729 729 return
730 730 try:
731 731 # may set last_syntax_error again if a SyntaxError is raised
732 732 self.safe_execfile(err.filename,self.user_ns)
733 733 except:
734 734 self.showtraceback()
735 735 else:
736 736 try:
737 737 f = open(err.filename)
738 738 try:
739 739 # This should be inside a display_trap block and I
740 740 # think it is.
741 741 sys.displayhook(f.read())
742 742 finally:
743 743 f.close()
744 744 except:
745 745 self.showtraceback()
746 746
747 747 def _should_recompile(self,e):
748 748 """Utility routine for edit_syntax_error"""
749 749
750 750 if e.filename in ('<ipython console>','<input>','<string>',
751 751 '<console>','<BackgroundJob compilation>',
752 752 None):
753 753
754 754 return False
755 755 try:
756 756 if (self.autoedit_syntax and
757 757 not self.ask_yes_no('Return to editor to correct syntax error? '
758 758 '[Y/n] ','y')):
759 759 return False
760 760 except EOFError:
761 761 return False
762 762
763 763 def int0(x):
764 764 try:
765 765 return int(x)
766 766 except TypeError:
767 767 return 0
768 768 # always pass integer line and offset values to editor hook
769 769 try:
770 770 self.hooks.fix_error_editor(e.filename,
771 771 int0(e.lineno),int0(e.offset),e.msg)
772 772 except TryNext:
773 773 warn('Could not open editor')
774 774 return False
775 775 return True
776 776
777 777 #-------------------------------------------------------------------------
778 778 # Things related to exiting
779 779 #-------------------------------------------------------------------------
780 780
781 781 def ask_exit(self):
782 782 """ Ask the shell to exit. Can be overiden and used as a callback. """
783 783 self.exit_now = True
784 784
785 785 def exit(self):
786 786 """Handle interactive exit.
787 787
788 788 This method calls the ask_exit callback."""
789 789 if self.confirm_exit:
790 790 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y','n'):
791 791 self.ask_exit()
792 792 else:
793 793 self.ask_exit()
794 794
795 795 #-------------------------------------------------------------------------
796 796 # Things related to magics
797 797 #-------------------------------------------------------------------------
798 798
799 799 def init_magics(self):
800 800 super(TerminalInteractiveShell, self).init_magics()
801 801 self.register_magics(TerminalMagics)
802 802
803 803 def showindentationerror(self):
804 804 super(TerminalInteractiveShell, self).showindentationerror()
805 805 if not self.using_paste_magics:
806 806 print("If you want to paste code into IPython, try the "
807 807 "%paste and %cpaste magic functions.")
808 808
809 809
810 810 InteractiveShellABC.register(TerminalInteractiveShell)
@@ -1,376 +1,374 b''
1 1 #!/usr/bin/env python
2 2 # encoding: utf-8
3 3 """
4 4 The :class:`~IPython.core.application.Application` object for the command
5 5 line :command:`ipython` program.
6 6 """
7 7
8 8 # Copyright (c) IPython Development Team.
9 9 # Distributed under the terms of the Modified BSD License.
10 10
11 11 from __future__ import absolute_import
12 12 from __future__ import print_function
13 13
14 14 import logging
15 15 import os
16 16 import sys
17 17 import warnings
18 18
19 19 from traitlets.config.loader import Config
20 20 from traitlets.config.application import boolean_flag, catch_config_error, Application
21 21 from IPython.core import release
22 22 from IPython.core import usage
23 23 from IPython.core.completer import IPCompleter
24 24 from IPython.core.crashhandler import CrashHandler
25 25 from IPython.core.formatters import PlainTextFormatter
26 26 from IPython.core.history import HistoryManager
27 from IPython.core.prompts import PromptManager
28 27 from IPython.core.application import (
29 28 ProfileDir, BaseIPythonApplication, base_flags, base_aliases
30 29 )
31 30 from IPython.core.magics import ScriptMagics
32 31 from IPython.core.shellapp import (
33 32 InteractiveShellApp, shell_flags, shell_aliases
34 33 )
35 34 from IPython.extensions.storemagic import StoreMagics
36 35 from .ptshell import TerminalInteractiveShell
37 36 from IPython.paths import get_ipython_dir
38 37 from traitlets import (
39 38 Bool, List, Dict, default, observe,
40 39 )
41 40
42 41 #-----------------------------------------------------------------------------
43 42 # Globals, utilities and helpers
44 43 #-----------------------------------------------------------------------------
45 44
46 45 _examples = """
47 46 ipython --matplotlib # enable matplotlib integration
48 47 ipython --matplotlib=qt # enable matplotlib integration with qt4 backend
49 48
50 49 ipython --log-level=DEBUG # set logging to DEBUG
51 50 ipython --profile=foo # start with profile foo
52 51
53 52 ipython profile create foo # create profile foo w/ default config files
54 53 ipython help profile # show the help for the profile subcmd
55 54
56 55 ipython locate # print the path to the IPython directory
57 56 ipython locate profile foo # print the path to the directory for profile `foo`
58 57 """
59 58
60 59 #-----------------------------------------------------------------------------
61 60 # Crash handler for this application
62 61 #-----------------------------------------------------------------------------
63 62
64 63 class IPAppCrashHandler(CrashHandler):
65 64 """sys.excepthook for IPython itself, leaves a detailed report on disk."""
66 65
67 66 def __init__(self, app):
68 67 contact_name = release.author
69 68 contact_email = release.author_email
70 69 bug_tracker = 'https://github.com/ipython/ipython/issues'
71 70 super(IPAppCrashHandler,self).__init__(
72 71 app, contact_name, contact_email, bug_tracker
73 72 )
74 73
75 74 def make_report(self,traceback):
76 75 """Return a string containing a crash report."""
77 76
78 77 sec_sep = self.section_sep
79 78 # Start with parent report
80 79 report = [super(IPAppCrashHandler, self).make_report(traceback)]
81 80 # Add interactive-specific info we may have
82 81 rpt_add = report.append
83 82 try:
84 83 rpt_add(sec_sep+"History of session input:")
85 84 for line in self.app.shell.user_ns['_ih']:
86 85 rpt_add(line)
87 86 rpt_add('\n*** Last line of input (may not be in above history):\n')
88 87 rpt_add(self.app.shell._last_input_line+'\n')
89 88 except:
90 89 pass
91 90
92 91 return ''.join(report)
93 92
94 93 #-----------------------------------------------------------------------------
95 94 # Aliases and Flags
96 95 #-----------------------------------------------------------------------------
97 96 flags = dict(base_flags)
98 97 flags.update(shell_flags)
99 98 frontend_flags = {}
100 99 addflag = lambda *args: frontend_flags.update(boolean_flag(*args))
101 100 addflag('autoedit-syntax', 'TerminalInteractiveShell.autoedit_syntax',
102 101 'Turn on auto editing of files with syntax errors.',
103 102 'Turn off auto editing of files with syntax errors.'
104 103 )
105 104 addflag('simple-prompt', 'TerminalInteractiveShell.simple_prompt',
106 105 "Force simple minimal prompt using `raw_input`",
107 106 "Use a rich interactive prompt with prompt_toolkit",
108 107 )
109 108
110 109 addflag('banner', 'TerminalIPythonApp.display_banner',
111 110 "Display a banner upon starting IPython.",
112 111 "Don't display a banner upon starting IPython."
113 112 )
114 113 addflag('confirm-exit', 'TerminalInteractiveShell.confirm_exit',
115 114 """Set to confirm when you try to exit IPython with an EOF (Control-D
116 115 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
117 116 you can force a direct exit without any confirmation.""",
118 117 "Don't prompt the user when exiting."
119 118 )
120 119 addflag('term-title', 'TerminalInteractiveShell.term_title',
121 120 "Enable auto setting the terminal title.",
122 121 "Disable auto setting the terminal title."
123 122 )
124 123 classic_config = Config()
125 124 classic_config.InteractiveShell.cache_size = 0
126 125 classic_config.PlainTextFormatter.pprint = False
127 126 classic_config.PromptManager.in_template = '>>> '
128 127 classic_config.PromptManager.in2_template = '... '
129 128 classic_config.PromptManager.out_template = ''
130 129 classic_config.InteractiveShell.separate_in = ''
131 130 classic_config.InteractiveShell.separate_out = ''
132 131 classic_config.InteractiveShell.separate_out2 = ''
133 132 classic_config.InteractiveShell.colors = 'NoColor'
134 133 classic_config.InteractiveShell.xmode = 'Plain'
135 134
136 135 frontend_flags['classic']=(
137 136 classic_config,
138 137 "Gives IPython a similar feel to the classic Python prompt."
139 138 )
140 139 # # log doesn't make so much sense this way anymore
141 140 # paa('--log','-l',
142 141 # action='store_true', dest='InteractiveShell.logstart',
143 142 # help="Start logging to the default log file (./ipython_log.py).")
144 143 #
145 144 # # quick is harder to implement
146 145 frontend_flags['quick']=(
147 146 {'TerminalIPythonApp' : {'quick' : True}},
148 147 "Enable quick startup with no config files."
149 148 )
150 149
151 150 frontend_flags['i'] = (
152 151 {'TerminalIPythonApp' : {'force_interact' : True}},
153 152 """If running code from the command line, become interactive afterwards.
154 153 It is often useful to follow this with `--` to treat remaining flags as
155 154 script arguments.
156 155 """
157 156 )
158 157 flags.update(frontend_flags)
159 158
160 159 aliases = dict(base_aliases)
161 160 aliases.update(shell_aliases)
162 161
163 162 #-----------------------------------------------------------------------------
164 163 # Main classes and functions
165 164 #-----------------------------------------------------------------------------
166 165
167 166
168 167 class LocateIPythonApp(BaseIPythonApplication):
169 168 description = """print the path to the IPython dir"""
170 169 subcommands = Dict(dict(
171 170 profile=('IPython.core.profileapp.ProfileLocate',
172 171 "print the path to an IPython profile directory",
173 172 ),
174 173 ))
175 174 def start(self):
176 175 if self.subapp is not None:
177 176 return self.subapp.start()
178 177 else:
179 178 print(self.ipython_dir)
180 179
181 180
182 181 class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):
183 182 name = u'ipython'
184 183 description = usage.cl_usage
185 184 crash_handler_class = IPAppCrashHandler
186 185 examples = _examples
187 186
188 187 flags = Dict(flags)
189 188 aliases = Dict(aliases)
190 189 classes = List()
191 190 @default('classes')
192 191 def _classes_default(self):
193 192 """This has to be in a method, for TerminalIPythonApp to be available."""
194 193 return [
195 194 InteractiveShellApp, # ShellApp comes before TerminalApp, because
196 195 self.__class__, # it will also affect subclasses (e.g. QtConsole)
197 196 TerminalInteractiveShell,
198 PromptManager,
199 197 HistoryManager,
200 198 ProfileDir,
201 199 PlainTextFormatter,
202 200 IPCompleter,
203 201 ScriptMagics,
204 202 StoreMagics,
205 203 ]
206 204
207 205 deprecated_subcommands = dict(
208 206 qtconsole=('qtconsole.qtconsoleapp.JupyterQtConsoleApp',
209 207 """DEPRECATED, Will be removed in IPython 6.0 : Launch the Jupyter Qt Console."""
210 208 ),
211 209 notebook=('notebook.notebookapp.NotebookApp',
212 210 """DEPRECATED, Will be removed in IPython 6.0 : Launch the Jupyter HTML Notebook Server."""
213 211 ),
214 212 console=('jupyter_console.app.ZMQTerminalIPythonApp',
215 213 """DEPRECATED, Will be removed in IPython 6.0 : Launch the Jupyter terminal-based Console."""
216 214 ),
217 215 nbconvert=('nbconvert.nbconvertapp.NbConvertApp',
218 216 "DEPRECATED, Will be removed in IPython 6.0 : Convert notebooks to/from other formats."
219 217 ),
220 218 trust=('nbformat.sign.TrustNotebookApp',
221 219 "DEPRECATED, Will be removed in IPython 6.0 : Sign notebooks to trust their potentially unsafe contents at load."
222 220 ),
223 221 kernelspec=('jupyter_client.kernelspecapp.KernelSpecApp',
224 222 "DEPRECATED, Will be removed in IPython 6.0 : Manage Jupyter kernel specifications."
225 223 ),
226 224 )
227 225 subcommands = dict(
228 226 profile = ("IPython.core.profileapp.ProfileApp",
229 227 "Create and manage IPython profiles."
230 228 ),
231 229 kernel = ("ipykernel.kernelapp.IPKernelApp",
232 230 "Start a kernel without an attached frontend."
233 231 ),
234 232 locate=('IPython.terminal.ipapp.LocateIPythonApp',
235 233 LocateIPythonApp.description
236 234 ),
237 235 history=('IPython.core.historyapp.HistoryApp',
238 236 "Manage the IPython history database."
239 237 ),
240 238 )
241 239 deprecated_subcommands['install-nbextension'] = (
242 240 "notebook.nbextensions.InstallNBExtensionApp",
243 241 "DEPRECATED, Will be removed in IPython 6.0 : Install Jupyter notebook extension files"
244 242 )
245 243 subcommands.update(deprecated_subcommands)
246 244
247 245 # *do* autocreate requested profile, but don't create the config file.
248 246 auto_create=Bool(True)
249 247 # configurables
250 248 quick = Bool(False,
251 249 help="""Start IPython quickly by skipping the loading of config files."""
252 250 ).tag(config=True)
253 251 @observe('quick')
254 252 def _quick_changed(self, change):
255 253 if change['new']:
256 254 self.load_config_file = lambda *a, **kw: None
257 255
258 256 display_banner = Bool(True,
259 257 help="Whether to display a banner upon starting IPython."
260 258 ).tag(config=True)
261 259
262 260 # if there is code of files to run from the cmd line, don't interact
263 261 # unless the --i flag (App.force_interact) is true.
264 262 force_interact = Bool(False,
265 263 help="""If a command or file is given via the command-line,
266 264 e.g. 'ipython foo.py', start an interactive shell after executing the
267 265 file or command."""
268 266 ).tag(config=True)
269 267 @observe('force_interact')
270 268 def _force_interact_changed(self, change):
271 269 if change['new']:
272 270 self.interact = True
273 271
274 272 @observe('file_to_run', 'code_to_run', 'module_to_run')
275 273 def _file_to_run_changed(self, change):
276 274 new = change['new']
277 275 if new:
278 276 self.something_to_run = True
279 277 if new and not self.force_interact:
280 278 self.interact = False
281 279
282 280 # internal, not-configurable
283 281 something_to_run=Bool(False)
284 282
285 283 def parse_command_line(self, argv=None):
286 284 """override to allow old '-pylab' flag with deprecation warning"""
287 285
288 286 argv = sys.argv[1:] if argv is None else argv
289 287
290 288 if '-pylab' in argv:
291 289 # deprecated `-pylab` given,
292 290 # warn and transform into current syntax
293 291 argv = argv[:] # copy, don't clobber
294 292 idx = argv.index('-pylab')
295 293 warnings.warn("`-pylab` flag has been deprecated.\n"
296 294 " Use `--matplotlib <backend>` and import pylab manually.")
297 295 argv[idx] = '--pylab'
298 296
299 297 return super(TerminalIPythonApp, self).parse_command_line(argv)
300 298
301 299 @catch_config_error
302 300 def initialize(self, argv=None):
303 301 """Do actions after construct, but before starting the app."""
304 302 super(TerminalIPythonApp, self).initialize(argv)
305 303 if self.subapp is not None:
306 304 # don't bother initializing further, starting subapp
307 305 return
308 306 # print self.extra_args
309 307 if self.extra_args and not self.something_to_run:
310 308 self.file_to_run = self.extra_args[0]
311 309 self.init_path()
312 310 # create the shell
313 311 self.init_shell()
314 312 # and draw the banner
315 313 self.init_banner()
316 314 # Now a variety of things that happen after the banner is printed.
317 315 self.init_gui_pylab()
318 316 self.init_extensions()
319 317 self.init_code()
320 318
321 319 def init_shell(self):
322 320 """initialize the InteractiveShell instance"""
323 321 # Create an InteractiveShell instance.
324 322 # shell.display_banner should always be False for the terminal
325 323 # based app, because we call shell.show_banner() by hand below
326 324 # so the banner shows *before* all extension loading stuff.
327 325 self.shell = TerminalInteractiveShell.instance(parent=self,
328 326 profile_dir=self.profile_dir,
329 327 ipython_dir=self.ipython_dir, user_ns=self.user_ns)
330 328 self.shell.configurables.append(self)
331 329
332 330 def init_banner(self):
333 331 """optionally display the banner"""
334 332 if self.display_banner and self.interact:
335 333 self.shell.show_banner()
336 334 # Make sure there is a space below the banner.
337 335 if self.log_level <= logging.INFO: print()
338 336
339 337 def _pylab_changed(self, name, old, new):
340 338 """Replace --pylab='inline' with --pylab='auto'"""
341 339 if new == 'inline':
342 340 warnings.warn("'inline' not available as pylab backend, "
343 341 "using 'auto' instead.")
344 342 self.pylab = 'auto'
345 343
346 344 def start(self):
347 345 if self.subapp is not None:
348 346 return self.subapp.start()
349 347 # perform any prexec steps:
350 348 if self.interact:
351 349 self.log.debug("Starting IPython's mainloop...")
352 350 self.shell.mainloop()
353 351 else:
354 352 self.log.debug("IPython not interactive...")
355 353
356 354 def load_default_config(ipython_dir=None):
357 355 """Load the default config file from the default ipython_dir.
358 356
359 357 This is useful for embedded shells.
360 358 """
361 359 if ipython_dir is None:
362 360 ipython_dir = get_ipython_dir()
363 361
364 362 profile_dir = os.path.join(ipython_dir, 'profile_default')
365 363
366 364 config = Config()
367 365 for cf in Application._load_config_files("ipython_config", path=profile_dir):
368 366 config.update(cf)
369 367
370 368 return config
371 369
372 370 launch_new_instance = TerminalIPythonApp.launch_instance
373 371
374 372
375 373 if __name__ == '__main__':
376 374 launch_new_instance()
@@ -1,444 +1,470 b''
1 1 """IPython terminal interface using prompt_toolkit in place of readline"""
2 2 from __future__ import print_function
3 3
4 4 import os
5 5 import sys
6 6 import signal
7 7 from warnings import warn
8 8
9 9 from IPython.core.error import TryNext
10 10 from IPython.core.interactiveshell import InteractiveShell
11 11 from IPython.utils.py3compat import cast_unicode_py2, input
12 12 from IPython.utils.terminal import toggle_set_term_title, set_term_title
13 13 from IPython.utils.process import abbrev_cwd
14 from traitlets import Bool, Unicode, Dict, Integer, observe
14 from traitlets import Bool, Unicode, Dict, Integer, observe, Instance
15 15
16 16 from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER, EditingMode
17 17 from prompt_toolkit.filters import HasFocus, HasSelection, Condition, ViInsertMode, EmacsInsertMode, IsDone
18 18 from prompt_toolkit.history import InMemoryHistory
19 19 from prompt_toolkit.shortcuts import create_prompt_application, create_eventloop, create_prompt_layout
20 20 from prompt_toolkit.interface import CommandLineInterface
21 21 from prompt_toolkit.key_binding.manager import KeyBindingManager
22 22 from prompt_toolkit.keys import Keys
23 23 from prompt_toolkit.layout.processors import ConditionalProcessor, HighlightMatchingBracketProcessor
24 24 from prompt_toolkit.styles import PygmentsStyle, DynamicStyle
25 25
26 26 from pygments.styles import get_style_by_name, get_all_styles
27 27 from pygments.token import Token
28 28
29 29 from .debugger import TerminalPdb, Pdb
30 30 from .pt_inputhooks import get_inputhook_func
31 31 from .interactiveshell import get_default_editor, TerminalMagics
32 from .prompts import Prompts, ClassicPrompts, RichPromptDisplayHook
32 33 from .ptutils import IPythonPTCompleter, IPythonPTLexer
33 34
34 35 _use_simple_prompt = 'IPY_TEST_SIMPLE_PROMPT' in os.environ or not sys.stdin.isatty()
35 36
36 37 class TerminalInteractiveShell(InteractiveShell):
37 38 colors_force = True
38 39
39 40 space_for_menu = Integer(6, help='Number of line at the bottom of the screen '
40 41 'to reserve for the completion menu'
41 42 ).tag(config=True)
42 43
43 44 def _space_for_menu_changed(self, old, new):
44 45 self._update_layout()
45 46
46 47 pt_cli = None
47 48 debugger_history = None
48 49
49 50 simple_prompt = Bool(_use_simple_prompt,
50 51 help="""Use `raw_input` for the REPL, without completion, multiline input, and prompt colors.
51 52
52 53 Useful when controlling IPython as a subprocess, and piping STDIN/OUT/ERR. Known usage are:
53 54 IPython own testing machinery, and emacs inferior-shell integration through elpy.
54 55
55 56 This mode default to `True` if the `IPY_TEST_SIMPLE_PROMPT`
56 57 environment variable is set, or the current terminal is not a tty.
57 58
58 59 """
59 60 ).tag(config=True)
60 61
61 62 @property
62 63 def debugger_cls(self):
63 64 return Pdb if self.simple_prompt else TerminalPdb
64 65
65 66 autoedit_syntax = Bool(False,
66 67 help="auto editing of files with syntax errors.",
67 68 ).tag(config=True)
68 69
69 70
70 71 confirm_exit = Bool(True,
71 72 help="""
72 73 Set to confirm when you try to exit IPython with an EOF (Control-D
73 74 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
74 75 you can force a direct exit without any confirmation.""",
75 76 ).tag(config=True)
76 77
77 78 editing_mode = Unicode('emacs',
78 79 help="Shortcut style to use at the prompt. 'vi' or 'emacs'.",
79 80 ).tag(config=True)
80 81
81 82 mouse_support = Bool(False,
82 83 help="Enable mouse support in the prompt"
83 84 ).tag(config=True)
84 85
85 86 highlighting_style = Unicode('default',
86 87 help="The name of a Pygments style to use for syntax highlighting: \n %s" % ', '.join(get_all_styles())
87 88 ).tag(config=True)
88 89
89 90
90 91 @observe('highlighting_style')
91 92 def _highlighting_style_changed(self, change):
92 93 self._style = self._make_style_from_name(self.highlighting_style)
93 94
94 95 highlighting_style_overrides = Dict(
95 96 help="Override highlighting format for specific tokens"
96 97 ).tag(config=True)
97 98
98 99 editor = Unicode(get_default_editor(),
99 100 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
100 101 ).tag(config=True)
101
102
103 prompts = Instance(Prompts)
104
105 def _prompts_default(self):
106 return Prompts(self)
107
108 @observe('prompts')
109 def _(self, change):
110 self._update_layout()
111
112 def _displayhook_class_default(self):
113 return RichPromptDisplayHook
114
102 115 term_title = Bool(True,
103 116 help="Automatically set the terminal title"
104 117 ).tag(config=True)
105 118
106 119 display_completions_in_columns = Bool(False,
107 120 help="Display a multi column completion menu.",
108 121 ).tag(config=True)
109 122
110 123 highlight_matching_brackets = Bool(True,
111 124 help="Highlight matching brackets .",
112 125 ).tag(config=True)
113 126
114 127 @observe('term_title')
115 128 def init_term_title(self, change=None):
116 129 # Enable or disable the terminal title.
117 130 if self.term_title:
118 131 toggle_set_term_title(True)
119 132 set_term_title('IPython: ' + abbrev_cwd())
120 133 else:
121 134 toggle_set_term_title(False)
122 135
123 def get_prompt_tokens(self, cli):
124 return [
125 (Token.Prompt, 'In ['),
126 (Token.PromptNum, str(self.execution_count)),
127 (Token.Prompt, ']: '),
128 ]
129
130 def get_continuation_tokens(self, cli, width):
131 return [
132 (Token.Prompt, (' ' * (width - 5)) + '...: '),
133 ]
134
135 136 def init_prompt_toolkit_cli(self):
136 137 if self.simple_prompt:
137 138 # Fall back to plain non-interactive output for tests.
138 139 # This is very limited, and only accepts a single line.
139 140 def prompt():
140 141 return cast_unicode_py2(input('In [%d]: ' % self.execution_count))
141 142 self.prompt_for_code = prompt
142 143 return
143 144
144 145 kbmanager = KeyBindingManager.for_prompt()
145 146 insert_mode = ViInsertMode() | EmacsInsertMode()
146 147 # Ctrl+J == Enter, seemingly
147 148 @kbmanager.registry.add_binding(Keys.ControlJ,
148 149 filter=(HasFocus(DEFAULT_BUFFER)
149 150 & ~HasSelection()
150 151 & insert_mode
151 152 ))
152 153 def _(event):
153 154 b = event.current_buffer
154 155 d = b.document
155 156 if not (d.on_last_line or d.cursor_position_row >= d.line_count
156 157 - d.empty_line_count_at_the_end()):
157 158 b.newline()
158 159 return
159 160
160 161 status, indent = self.input_splitter.check_complete(d.text)
161 162
162 163 if (status != 'incomplete') and b.accept_action.is_returnable:
163 164 b.accept_action.validate_and_handle(event.cli, b)
164 165 else:
165 166 b.insert_text('\n' + (' ' * (indent or 0)))
166 167
167 168 @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(DEFAULT_BUFFER))
168 169 def _reset_buffer(event):
169 170 event.current_buffer.reset()
170 171
171 172 @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(SEARCH_BUFFER))
172 173 def _reset_search_buffer(event):
173 174 if event.current_buffer.document.text:
174 175 event.current_buffer.reset()
175 176 else:
176 177 event.cli.push_focus(DEFAULT_BUFFER)
177 178
178 179 supports_suspend = Condition(lambda cli: hasattr(signal, 'SIGTSTP'))
179 180
180 181 @kbmanager.registry.add_binding(Keys.ControlZ, filter=supports_suspend)
181 182 def _suspend_to_bg(event):
182 183 event.cli.suspend_to_background()
183 184
184 185 @Condition
185 186 def cursor_in_leading_ws(cli):
186 187 before = cli.application.buffer.document.current_line_before_cursor
187 188 return (not before) or before.isspace()
188 189
189 190 # Ctrl+I == Tab
190 191 @kbmanager.registry.add_binding(Keys.ControlI,
191 192 filter=(HasFocus(DEFAULT_BUFFER)
192 193 & ~HasSelection()
193 194 & insert_mode
194 195 & cursor_in_leading_ws
195 196 ))
196 197 def _indent_buffer(event):
197 198 event.current_buffer.insert_text(' ' * 4)
198 199
199 200 # Pre-populate history from IPython's history database
200 201 history = InMemoryHistory()
201 202 last_cell = u""
202 203 for __, ___, cell in self.history_manager.get_tail(self.history_load_length,
203 204 include_latest=True):
204 205 # Ignore blank lines and consecutive duplicates
205 206 cell = cell.rstrip()
206 207 if cell and (cell != last_cell):
207 208 history.append(cell)
208 209
209 210 self._style = self._make_style_from_name(self.highlighting_style)
210 211 style = DynamicStyle(lambda: self._style)
211 212
212 213 editing_mode = getattr(EditingMode, self.editing_mode.upper())
213 214
214 215 self._app = create_prompt_application(
215 216 editing_mode=editing_mode,
216 217 key_bindings_registry=kbmanager.registry,
217 218 history=history,
218 219 completer=IPythonPTCompleter(self.Completer),
219 220 enable_history_search=True,
220 221 style=style,
221 222 mouse_support=self.mouse_support,
222 223 **self._layout_options()
223 224 )
224 225 self._eventloop = create_eventloop(self.inputhook)
225 226 self.pt_cli = CommandLineInterface(self._app, eventloop=self._eventloop)
226 227
227 228 def _make_style_from_name(self, name):
228 229 """
229 230 Small wrapper that make an IPython compatible style from a style name
230 231
231 232 We need that to add style for prompt ... etc.
232 233 """
233 234 style_cls = get_style_by_name(name)
234 235 style_overrides = {
235 236 Token.Prompt: '#009900',
236 237 Token.PromptNum: '#00ff00 bold',
238 Token.OutPrompt: '#990000',
239 Token.OutPromptNum: '#ff0000 bold',
237 240 }
238 241 if name == 'default':
239 242 style_cls = get_style_by_name('default')
240 243 # The default theme needs to be visible on both a dark background
241 244 # and a light background, because we can't tell what the terminal
242 245 # looks like. These tweaks to the default theme help with that.
243 246 style_overrides.update({
244 247 Token.Number: '#007700',
245 248 Token.Operator: 'noinherit',
246 249 Token.String: '#BB6622',
247 250 Token.Name.Function: '#2080D0',
248 251 Token.Name.Class: 'bold #2080D0',
249 252 Token.Name.Namespace: 'bold #2080D0',
250 253 })
251 254 style_overrides.update(self.highlighting_style_overrides)
252 255 style = PygmentsStyle.from_defaults(pygments_style_cls=style_cls,
253 256 style_dict=style_overrides)
254 257
255 258 return style
256 259
257 260 def _layout_options(self):
258 261 """
259 262 Return the current layout option for the current Terminal InteractiveShell
260 263 """
261 264 return {
262 265 'lexer':IPythonPTLexer(),
263 266 'reserve_space_for_menu':self.space_for_menu,
264 'get_prompt_tokens':self.get_prompt_tokens,
265 'get_continuation_tokens':self.get_continuation_tokens,
267 'get_prompt_tokens':self.prompts.in_prompt_tokens,
268 'get_continuation_tokens':self.prompts.continuation_prompt_tokens,
266 269 'multiline':True,
267 270 'display_completions_in_columns': self.display_completions_in_columns,
268 271
269 272 # Highlight matching brackets, but only when this setting is
270 273 # enabled, and only when the DEFAULT_BUFFER has the focus.
271 274 'extra_input_processors': [ConditionalProcessor(
272 275 processor=HighlightMatchingBracketProcessor(chars='[](){}'),
273 276 filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
274 277 Condition(lambda cli: self.highlight_matching_brackets))],
275 278 }
276 279
277 280 def _update_layout(self):
278 281 """
279 282 Ask for a re computation of the application layout, if for example ,
280 283 some configuration options have changed.
281 284 """
282 285 self._app.layout = create_prompt_layout(**self._layout_options())
283 286
284 287 def prompt_for_code(self):
285 288 document = self.pt_cli.run(
286 289 pre_run=self.pre_prompt, reset_current_buffer=True)
287 290 return document.text
288 291
289 292 def init_io(self):
290 293 if sys.platform not in {'win32', 'cli'}:
291 294 return
292 295
293 296 import colorama
294 297 colorama.init()
295 298
296 299 # For some reason we make these wrappers around stdout/stderr.
297 300 # For now, we need to reset them so all output gets coloured.
298 301 # https://github.com/ipython/ipython/issues/8669
299 302 from IPython.utils import io
300 303 io.stdout = io.IOStream(sys.stdout)
301 304 io.stderr = io.IOStream(sys.stderr)
302 305
303 306 def init_magics(self):
304 307 super(TerminalInteractiveShell, self).init_magics()
305 308 self.register_magics(TerminalMagics)
306 309
307 310 def init_alias(self):
308 311 # The parent class defines aliases that can be safely used with any
309 312 # frontend.
310 313 super(TerminalInteractiveShell, self).init_alias()
311 314
312 315 # Now define aliases that only make sense on the terminal, because they
313 316 # need direct access to the console in a way that we can't emulate in
314 317 # GUI or web frontend
315 318 if os.name == 'posix':
316 319 for cmd in ['clear', 'more', 'less', 'man']:
317 320 self.alias_manager.soft_define_alias(cmd, cmd)
318 321
319 322
320 323 def __init__(self, *args, **kwargs):
321 324 super(TerminalInteractiveShell, self).__init__(*args, **kwargs)
322 325 self.init_prompt_toolkit_cli()
323 326 self.init_term_title()
324 327 self.keep_running = True
325 328
326 329 self.debugger_history = InMemoryHistory()
327 330
328 331 def ask_exit(self):
329 332 self.keep_running = False
330 333
331 334 rl_next_input = None
332 335
333 336 def pre_prompt(self):
334 337 if self.rl_next_input:
335 338 self.pt_cli.application.buffer.text = cast_unicode_py2(self.rl_next_input)
336 339 self.rl_next_input = None
337 340
338 341 def interact(self):
339 342 while self.keep_running:
340 343 print(self.separate_in, end='')
341 344
342 345 try:
343 346 code = self.prompt_for_code()
344 347 except EOFError:
345 348 if (not self.confirm_exit) \
346 349 or self.ask_yes_no('Do you really want to exit ([y]/n)?','y','n'):
347 350 self.ask_exit()
348 351
349 352 else:
350 353 if code:
351 354 self.run_cell(code, store_history=True)
352 355 if self.autoedit_syntax and self.SyntaxTB.last_syntax_error:
353 356 self.edit_syntax_error()
354 357
355 358 def mainloop(self):
356 359 # An extra layer of protection in case someone mashing Ctrl-C breaks
357 360 # out of our internal code.
358 361 while True:
359 362 try:
360 363 self.interact()
361 364 break
362 365 except KeyboardInterrupt:
363 366 print("\nKeyboardInterrupt escaped interact()\n")
364 367
365 368 if hasattr(self, '_eventloop'):
366 369 self._eventloop.close()
367 370
368 371 _inputhook = None
369 372 def inputhook(self, context):
370 373 if self._inputhook is not None:
371 374 self._inputhook(context)
372 375
373 376 def enable_gui(self, gui=None):
374 377 if gui:
375 378 self._inputhook = get_inputhook_func(gui)
376 379 else:
377 380 self._inputhook = None
378 381
379 382 # Methods to support auto-editing of SyntaxErrors:
380 383
381 384 def edit_syntax_error(self):
382 385 """The bottom half of the syntax error handler called in the main loop.
383 386
384 387 Loop until syntax error is fixed or user cancels.
385 388 """
386 389
387 390 while self.SyntaxTB.last_syntax_error:
388 391 # copy and clear last_syntax_error
389 392 err = self.SyntaxTB.clear_err_state()
390 393 if not self._should_recompile(err):
391 394 return
392 395 try:
393 396 # may set last_syntax_error again if a SyntaxError is raised
394 397 self.safe_execfile(err.filename, self.user_ns)
395 398 except:
396 399 self.showtraceback()
397 400 else:
398 401 try:
399 402 with open(err.filename) as f:
400 403 # This should be inside a display_trap block and I
401 404 # think it is.
402 405 sys.displayhook(f.read())
403 406 except:
404 407 self.showtraceback()
405 408
406 409 def _should_recompile(self, e):
407 410 """Utility routine for edit_syntax_error"""
408 411
409 412 if e.filename in ('<ipython console>', '<input>', '<string>',
410 413 '<console>', '<BackgroundJob compilation>',
411 414 None):
412 415 return False
413 416 try:
414 417 if (self.autoedit_syntax and
415 418 not self.ask_yes_no(
416 419 'Return to editor to correct syntax error? '
417 420 '[Y/n] ', 'y')):
418 421 return False
419 422 except EOFError:
420 423 return False
421 424
422 425 def int0(x):
423 426 try:
424 427 return int(x)
425 428 except TypeError:
426 429 return 0
427 430
428 431 # always pass integer line and offset values to editor hook
429 432 try:
430 433 self.hooks.fix_error_editor(e.filename,
431 434 int0(e.lineno), int0(e.offset),
432 435 e.msg)
433 436 except TryNext:
434 437 warn('Could not open editor')
435 438 return False
436 439 return True
437 440
438 441 # Run !system commands directly, not through pipes, so terminal programs
439 442 # work correctly.
440 443 system = InteractiveShell.system_raw
441 444
445 def auto_rewrite_input(self, cmd):
446 """Overridden from the parent class to use fancy rewriting prompt"""
447 if not self.show_rewritten_input:
448 return
449
450 tokens = self.prompts.rewrite_prompt_tokens()
451 if self.pt_cli:
452 self.pt_cli.print_tokens(tokens)
453 print(cmd)
454 else:
455 prompt = ''.join(s for t, s in tokens)
456 print(prompt, cmd, sep='')
457
458 _prompts_before = None
459 def switch_doctest_mode(self, mode):
460 """Switch prompts to classic for %doctest_mode"""
461 if mode:
462 self._prompts_before = self.prompts
463 self.prompts = ClassicPrompts(self)
464 elif self._prompts_before:
465 self.prompts = self._prompts_before
466 self._prompts_before = None
467
442 468
443 469 if __name__ == '__main__':
444 470 TerminalInteractiveShell.instance().interact()
@@ -1,474 +1,468 b''
1 1 """Generic testing tools.
2 2
3 3 Authors
4 4 -------
5 5 - Fernando Perez <Fernando.Perez@berkeley.edu>
6 6 """
7 7
8 8 from __future__ import absolute_import
9 9
10 10 #-----------------------------------------------------------------------------
11 11 # Copyright (C) 2009 The IPython Development Team
12 12 #
13 13 # Distributed under the terms of the BSD License. The full license is in
14 14 # the file COPYING, distributed as part of this software.
15 15 #-----------------------------------------------------------------------------
16 16
17 17 #-----------------------------------------------------------------------------
18 18 # Imports
19 19 #-----------------------------------------------------------------------------
20 20
21 21 import os
22 22 import re
23 23 import sys
24 24 import tempfile
25 25
26 26 from contextlib import contextmanager
27 27 from io import StringIO
28 28 from subprocess import Popen, PIPE
29 29
30 30 try:
31 31 # These tools are used by parts of the runtime, so we make the nose
32 32 # dependency optional at this point. Nose is a hard dependency to run the
33 33 # test suite, but NOT to use ipython itself.
34 34 import nose.tools as nt
35 35 has_nose = True
36 36 except ImportError:
37 37 has_nose = False
38 38
39 39 from traitlets.config.loader import Config
40 40 from IPython.utils.process import get_output_error_code
41 41 from IPython.utils.text import list_strings
42 42 from IPython.utils.io import temp_pyfile, Tee
43 43 from IPython.utils import py3compat
44 44 from IPython.utils.encoding import DEFAULT_ENCODING
45 45
46 46 from . import decorators as dec
47 47 from . import skipdoctest
48 48
49 49 #-----------------------------------------------------------------------------
50 50 # Functions and classes
51 51 #-----------------------------------------------------------------------------
52 52
53 53 # The docstring for full_path doctests differently on win32 (different path
54 54 # separator) so just skip the doctest there. The example remains informative.
55 55 doctest_deco = skipdoctest.skip_doctest if sys.platform == 'win32' else dec.null_deco
56 56
57 57 @doctest_deco
58 58 def full_path(startPath,files):
59 59 """Make full paths for all the listed files, based on startPath.
60 60
61 61 Only the base part of startPath is kept, since this routine is typically
62 62 used with a script's ``__file__`` variable as startPath. The base of startPath
63 63 is then prepended to all the listed files, forming the output list.
64 64
65 65 Parameters
66 66 ----------
67 67 startPath : string
68 68 Initial path to use as the base for the results. This path is split
69 69 using os.path.split() and only its first component is kept.
70 70
71 71 files : string or list
72 72 One or more files.
73 73
74 74 Examples
75 75 --------
76 76
77 77 >>> full_path('/foo/bar.py',['a.txt','b.txt'])
78 78 ['/foo/a.txt', '/foo/b.txt']
79 79
80 80 >>> full_path('/foo',['a.txt','b.txt'])
81 81 ['/a.txt', '/b.txt']
82 82
83 83 If a single file is given, the output is still a list::
84 84
85 85 >>> full_path('/foo','a.txt')
86 86 ['/a.txt']
87 87 """
88 88
89 89 files = list_strings(files)
90 90 base = os.path.split(startPath)[0]
91 91 return [ os.path.join(base,f) for f in files ]
92 92
93 93
94 94 def parse_test_output(txt):
95 95 """Parse the output of a test run and return errors, failures.
96 96
97 97 Parameters
98 98 ----------
99 99 txt : str
100 100 Text output of a test run, assumed to contain a line of one of the
101 101 following forms::
102 102
103 103 'FAILED (errors=1)'
104 104 'FAILED (failures=1)'
105 105 'FAILED (errors=1, failures=1)'
106 106
107 107 Returns
108 108 -------
109 109 nerr, nfail
110 110 number of errors and failures.
111 111 """
112 112
113 113 err_m = re.search(r'^FAILED \(errors=(\d+)\)', txt, re.MULTILINE)
114 114 if err_m:
115 115 nerr = int(err_m.group(1))
116 116 nfail = 0
117 117 return nerr, nfail
118 118
119 119 fail_m = re.search(r'^FAILED \(failures=(\d+)\)', txt, re.MULTILINE)
120 120 if fail_m:
121 121 nerr = 0
122 122 nfail = int(fail_m.group(1))
123 123 return nerr, nfail
124 124
125 125 both_m = re.search(r'^FAILED \(errors=(\d+), failures=(\d+)\)', txt,
126 126 re.MULTILINE)
127 127 if both_m:
128 128 nerr = int(both_m.group(1))
129 129 nfail = int(both_m.group(2))
130 130 return nerr, nfail
131 131
132 132 # If the input didn't match any of these forms, assume no error/failures
133 133 return 0, 0
134 134
135 135
136 136 # So nose doesn't think this is a test
137 137 parse_test_output.__test__ = False
138 138
139 139
140 140 def default_argv():
141 141 """Return a valid default argv for creating testing instances of ipython"""
142 142
143 143 return ['--quick', # so no config file is loaded
144 144 # Other defaults to minimize side effects on stdout
145 145 '--colors=NoColor', '--no-term-title','--no-banner',
146 146 '--autocall=0']
147 147
148 148
149 149 def default_config():
150 150 """Return a config object with good defaults for testing."""
151 151 config = Config()
152 152 config.TerminalInteractiveShell.colors = 'NoColor'
153 153 config.TerminalTerminalInteractiveShell.term_title = False,
154 154 config.TerminalInteractiveShell.autocall = 0
155 155 f = tempfile.NamedTemporaryFile(suffix=u'test_hist.sqlite', delete=False)
156 156 config.HistoryManager.hist_file = f.name
157 157 f.close()
158 158 config.HistoryManager.db_cache_size = 10000
159 159 return config
160 160
161 161
162 162 def get_ipython_cmd(as_string=False):
163 163 """
164 164 Return appropriate IPython command line name. By default, this will return
165 165 a list that can be used with subprocess.Popen, for example, but passing
166 166 `as_string=True` allows for returning the IPython command as a string.
167 167
168 168 Parameters
169 169 ----------
170 170 as_string: bool
171 171 Flag to allow to return the command as a string.
172 172 """
173 173 ipython_cmd = [sys.executable, "-m", "IPython"]
174 174
175 175 if as_string:
176 176 ipython_cmd = " ".join(ipython_cmd)
177 177
178 178 return ipython_cmd
179 179
180 180 def ipexec(fname, options=None, commands=()):
181 181 """Utility to call 'ipython filename'.
182 182
183 183 Starts IPython with a minimal and safe configuration to make startup as fast
184 184 as possible.
185 185
186 186 Note that this starts IPython in a subprocess!
187 187
188 188 Parameters
189 189 ----------
190 190 fname : str
191 191 Name of file to be executed (should have .py or .ipy extension).
192 192
193 193 options : optional, list
194 194 Extra command-line flags to be passed to IPython.
195 195
196 196 commands : optional, list
197 197 Commands to send in on stdin
198 198
199 199 Returns
200 200 -------
201 201 (stdout, stderr) of ipython subprocess.
202 202 """
203 203 if options is None: options = []
204 204
205 # For these subprocess calls, eliminate all prompt printing so we only see
206 # output from script execution
207 prompt_opts = [ '--PromptManager.in_template=""',
208 '--PromptManager.in2_template=""',
209 '--PromptManager.out_template=""'
210 ]
211 cmdargs = default_argv() + prompt_opts + options
205 cmdargs = default_argv() + options
212 206
213 207 test_dir = os.path.dirname(__file__)
214 208
215 209 ipython_cmd = get_ipython_cmd()
216 210 # Absolute path for filename
217 211 full_fname = os.path.join(test_dir, fname)
218 212 full_cmd = ipython_cmd + cmdargs + [full_fname]
219 213 env = os.environ.copy()
220 214 # FIXME: ignore all warnings in ipexec while we have shims
221 215 # should we keep suppressing warnings here, even after removing shims?
222 216 env['PYTHONWARNINGS'] = 'ignore'
223 217 # env.pop('PYTHONWARNINGS', None) # Avoid extraneous warnings appearing on stderr
224 218 for k, v in env.items():
225 219 # Debug a bizarre failure we've seen on Windows:
226 220 # TypeError: environment can only contain strings
227 221 if not isinstance(v, str):
228 222 print(k, v)
229 223 p = Popen(full_cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE, env=env)
230 224 out, err = p.communicate(input=py3compat.str_to_bytes('\n'.join(commands)) or None)
231 225 out, err = py3compat.bytes_to_str(out), py3compat.bytes_to_str(err)
232 226 # `import readline` causes 'ESC[?1034h' to be output sometimes,
233 227 # so strip that out before doing comparisons
234 228 if out:
235 229 out = re.sub(r'\x1b\[[^h]+h', '', out)
236 230 return out, err
237 231
238 232
239 233 def ipexec_validate(fname, expected_out, expected_err='',
240 234 options=None, commands=()):
241 235 """Utility to call 'ipython filename' and validate output/error.
242 236
243 237 This function raises an AssertionError if the validation fails.
244 238
245 239 Note that this starts IPython in a subprocess!
246 240
247 241 Parameters
248 242 ----------
249 243 fname : str
250 244 Name of the file to be executed (should have .py or .ipy extension).
251 245
252 246 expected_out : str
253 247 Expected stdout of the process.
254 248
255 249 expected_err : optional, str
256 250 Expected stderr of the process.
257 251
258 252 options : optional, list
259 253 Extra command-line flags to be passed to IPython.
260 254
261 255 Returns
262 256 -------
263 257 None
264 258 """
265 259
266 260 import nose.tools as nt
267 261
268 262 out, err = ipexec(fname, options, commands)
269 263 #print 'OUT', out # dbg
270 264 #print 'ERR', err # dbg
271 265 # If there are any errors, we must check those befor stdout, as they may be
272 266 # more informative than simply having an empty stdout.
273 267 if err:
274 268 if expected_err:
275 269 nt.assert_equal("\n".join(err.strip().splitlines()), "\n".join(expected_err.strip().splitlines()))
276 270 else:
277 271 raise ValueError('Running file %r produced error: %r' %
278 272 (fname, err))
279 273 # If no errors or output on stderr was expected, match stdout
280 274 nt.assert_equal("\n".join(out.strip().splitlines()), "\n".join(expected_out.strip().splitlines()))
281 275
282 276
283 277 class TempFileMixin(object):
284 278 """Utility class to create temporary Python/IPython files.
285 279
286 280 Meant as a mixin class for test cases."""
287 281
288 282 def mktmp(self, src, ext='.py'):
289 283 """Make a valid python temp file."""
290 284 fname, f = temp_pyfile(src, ext)
291 285 self.tmpfile = f
292 286 self.fname = fname
293 287
294 288 def tearDown(self):
295 289 if hasattr(self, 'tmpfile'):
296 290 # If the tmpfile wasn't made because of skipped tests, like in
297 291 # win32, there's nothing to cleanup.
298 292 self.tmpfile.close()
299 293 try:
300 294 os.unlink(self.fname)
301 295 except:
302 296 # On Windows, even though we close the file, we still can't
303 297 # delete it. I have no clue why
304 298 pass
305 299
306 300 def __enter__(self):
307 301 return self
308 302
309 303 def __exit__(self, exc_type, exc_value, traceback):
310 304 self.tearDown()
311 305
312 306
313 307 pair_fail_msg = ("Testing {0}\n\n"
314 308 "In:\n"
315 309 " {1!r}\n"
316 310 "Expected:\n"
317 311 " {2!r}\n"
318 312 "Got:\n"
319 313 " {3!r}\n")
320 314 def check_pairs(func, pairs):
321 315 """Utility function for the common case of checking a function with a
322 316 sequence of input/output pairs.
323 317
324 318 Parameters
325 319 ----------
326 320 func : callable
327 321 The function to be tested. Should accept a single argument.
328 322 pairs : iterable
329 323 A list of (input, expected_output) tuples.
330 324
331 325 Returns
332 326 -------
333 327 None. Raises an AssertionError if any output does not match the expected
334 328 value.
335 329 """
336 330 name = getattr(func, "func_name", getattr(func, "__name__", "<unknown>"))
337 331 for inp, expected in pairs:
338 332 out = func(inp)
339 333 assert out == expected, pair_fail_msg.format(name, inp, expected, out)
340 334
341 335
342 336 if py3compat.PY3:
343 337 MyStringIO = StringIO
344 338 else:
345 339 # In Python 2, stdout/stderr can have either bytes or unicode written to them,
346 340 # so we need a class that can handle both.
347 341 class MyStringIO(StringIO):
348 342 def write(self, s):
349 343 s = py3compat.cast_unicode(s, encoding=DEFAULT_ENCODING)
350 344 super(MyStringIO, self).write(s)
351 345
352 346 _re_type = type(re.compile(r''))
353 347
354 348 notprinted_msg = """Did not find {0!r} in printed output (on {1}):
355 349 -------
356 350 {2!s}
357 351 -------
358 352 """
359 353
360 354 class AssertPrints(object):
361 355 """Context manager for testing that code prints certain text.
362 356
363 357 Examples
364 358 --------
365 359 >>> with AssertPrints("abc", suppress=False):
366 360 ... print("abcd")
367 361 ... print("def")
368 362 ...
369 363 abcd
370 364 def
371 365 """
372 366 def __init__(self, s, channel='stdout', suppress=True):
373 367 self.s = s
374 368 if isinstance(self.s, (py3compat.string_types, _re_type)):
375 369 self.s = [self.s]
376 370 self.channel = channel
377 371 self.suppress = suppress
378 372
379 373 def __enter__(self):
380 374 self.orig_stream = getattr(sys, self.channel)
381 375 self.buffer = MyStringIO()
382 376 self.tee = Tee(self.buffer, channel=self.channel)
383 377 setattr(sys, self.channel, self.buffer if self.suppress else self.tee)
384 378
385 379 def __exit__(self, etype, value, traceback):
386 380 try:
387 381 if value is not None:
388 382 # If an error was raised, don't check anything else
389 383 return False
390 384 self.tee.flush()
391 385 setattr(sys, self.channel, self.orig_stream)
392 386 printed = self.buffer.getvalue()
393 387 for s in self.s:
394 388 if isinstance(s, _re_type):
395 389 assert s.search(printed), notprinted_msg.format(s.pattern, self.channel, printed)
396 390 else:
397 391 assert s in printed, notprinted_msg.format(s, self.channel, printed)
398 392 return False
399 393 finally:
400 394 self.tee.close()
401 395
402 396 printed_msg = """Found {0!r} in printed output (on {1}):
403 397 -------
404 398 {2!s}
405 399 -------
406 400 """
407 401
408 402 class AssertNotPrints(AssertPrints):
409 403 """Context manager for checking that certain output *isn't* produced.
410 404
411 405 Counterpart of AssertPrints"""
412 406 def __exit__(self, etype, value, traceback):
413 407 try:
414 408 if value is not None:
415 409 # If an error was raised, don't check anything else
416 410 self.tee.close()
417 411 return False
418 412 self.tee.flush()
419 413 setattr(sys, self.channel, self.orig_stream)
420 414 printed = self.buffer.getvalue()
421 415 for s in self.s:
422 416 if isinstance(s, _re_type):
423 417 assert not s.search(printed),printed_msg.format(
424 418 s.pattern, self.channel, printed)
425 419 else:
426 420 assert s not in printed, printed_msg.format(
427 421 s, self.channel, printed)
428 422 return False
429 423 finally:
430 424 self.tee.close()
431 425
432 426 @contextmanager
433 427 def mute_warn():
434 428 from IPython.utils import warn
435 429 save_warn = warn.warn
436 430 warn.warn = lambda *a, **kw: None
437 431 try:
438 432 yield
439 433 finally:
440 434 warn.warn = save_warn
441 435
442 436 @contextmanager
443 437 def make_tempfile(name):
444 438 """ Create an empty, named, temporary file for the duration of the context.
445 439 """
446 440 f = open(name, 'w')
447 441 f.close()
448 442 try:
449 443 yield
450 444 finally:
451 445 os.unlink(name)
452 446
453 447
454 448 def help_output_test(subcommand=''):
455 449 """test that `ipython [subcommand] -h` works"""
456 450 cmd = get_ipython_cmd() + [subcommand, '-h']
457 451 out, err, rc = get_output_error_code(cmd)
458 452 nt.assert_equal(rc, 0, err)
459 453 nt.assert_not_in("Traceback", err)
460 454 nt.assert_in("Options", out)
461 455 nt.assert_in("--help-all", out)
462 456 return out, err
463 457
464 458
465 459 def help_all_output_test(subcommand=''):
466 460 """test that `ipython [subcommand] --help-all` works"""
467 461 cmd = get_ipython_cmd() + [subcommand, '--help-all']
468 462 out, err, rc = get_output_error_code(cmd)
469 463 nt.assert_equal(rc, 0, err)
470 464 nt.assert_not_in("Traceback", err)
471 465 nt.assert_in("Options", out)
472 466 nt.assert_in("Class parameters", out)
473 467 return out, err
474 468
@@ -1,184 +1,121 b''
1 1 =======================
2 2 Specific config details
3 3 =======================
4 4
5 Prompts
6 =======
7
8 In the terminal, the format of the input and output prompts can be
9 customised. This does not currently affect other frontends.
10
11 The following codes in the prompt string will be substituted into the
12 prompt string:
13
14 ====== =================================== =====================================================
15 Short Long Notes
16 ====== =================================== =====================================================
17 %n,\\# {color.number}{count}{color.prompt} history counter with bolding
18 \\N {count} history counter without bolding
19 \\D {dots} series of dots the same width as the history counter
20 \\T {time} current time
21 \\w {cwd} current working directory
22 \\W {cwd_last} basename of CWD
23 \\Xn {cwd_x[n]} Show the last n terms of the CWD. n=0 means show all.
24 \\Yn {cwd_y[n]} Like \Xn, but show '~' for $HOME
25 \\h hostname, up to the first '.'
26 \\H full hostname
27 \\u username (from the $USER environment variable)
28 \\v IPython version
29 \\$ root symbol ("$" for normal user or "#" for root)
30 ``\\`` escaped '\\'
31 \\n newline
32 \\r carriage return
33 n/a {color.<Name>} set terminal colour - see below for list of names
34 ====== =================================== =====================================================
35
36 Available colour names are: Black, BlinkBlack, BlinkBlue, BlinkCyan,
37 BlinkGreen, BlinkLightGray, BlinkPurple, BlinkRed, BlinkYellow, Blue,
38 Brown, Cyan, DarkGray, Green, LightBlue, LightCyan, LightGray, LightGreen,
39 LightPurple, LightRed, Purple, Red, White, Yellow. The selected colour
40 scheme also defines the names *prompt* and *number*. Finally, the name
41 *normal* resets the terminal to its default colour.
42
43 So, this config::
44
45 c.PromptManager.in_template = "{color.LightGreen}{time}{color.Yellow} \u{color.normal}>>>"
46
47 will produce input prompts with the time in light green, your username
48 in yellow, and a ``>>>`` prompt in the default terminal colour.
49
50
51 5 .. _termcolour:
52 6
53 7 Terminal Colors
54 8 ===============
55 9
56 10 The default IPython configuration has most bells and whistles turned on
57 11 (they're pretty safe). But there's one that may cause problems on some
58 12 systems: the use of color on screen for displaying information. This is
59 13 very useful, since IPython can show prompts and exception tracebacks
60 14 with various colors, display syntax-highlighted source code, and in
61 15 general make it easier to visually parse information.
62 16
63 17 The following terminals seem to handle the color sequences fine:
64 18
65 19 * Linux main text console, KDE Konsole, Gnome Terminal, E-term,
66 20 rxvt, xterm.
67 21 * CDE terminal (tested under Solaris). This one boldfaces light colors.
68 22 * (X)Emacs buffers. See the :ref:`emacs` section for more details on
69 23 using IPython with (X)Emacs.
70 24 * A Windows (XP/2k) command prompt with pyreadline_.
71 25 * A Windows (XP/2k) CygWin shell. Although some users have reported
72 26 problems; it is not clear whether there is an issue for everyone
73 27 or only under specific configurations. If you have full color
74 28 support under cygwin, please post to the IPython mailing list so
75 29 this issue can be resolved for all users.
76 30
77 31 .. _pyreadline: https://code.launchpad.net/pyreadline
78 32
79 33 These have shown problems:
80 34
81 35 * Windows command prompt in WinXP/2k logged into a Linux machine via
82 36 telnet or ssh.
83 37 * Windows native command prompt in WinXP/2k, without Gary Bishop's
84 38 extensions. Once Gary's readline library is installed, the normal
85 39 WinXP/2k command prompt works perfectly.
86 40
87 Currently the following color schemes are available:
88
89 * NoColor: uses no color escapes at all (all escapes are empty '' ''
90 strings). This 'scheme' is thus fully safe to use in any terminal.
91 * Linux: works well in Linux console type environments: dark
92 background with light fonts. It uses bright colors for
93 information, so it is difficult to read if you have a light
94 colored background.
95 * LightBG: the basic colors are similar to those in the Linux scheme
96 but darker. It is easy to read in terminals with light backgrounds.
97
98 41 IPython uses colors for two main groups of things: prompts and
99 42 tracebacks which are directly printed to the terminal, and the object
100 43 introspection system which passes large sets of data through a pager.
101 44
102 If you are seeing garbage sequences in your terminal and no colour, you
103 may need to disable colours: run ``%colors NoColor`` inside IPython, or
104 add this to a config file::
105
106 c.InteractiveShell.colors = 'NoColor'
107
108 45 Colors in the pager
109 46 -------------------
110 47
111 48 On some systems, the default pager has problems with ANSI colour codes.
112 49 To configure your default pager to allow these:
113 50
114 51 1. Set the environment PAGER variable to ``less``.
115 52 2. Set the environment LESS variable to ``-r`` (plus any other options
116 53 you always want to pass to less by default). This tells less to
117 54 properly interpret control sequences, which is how color
118 55 information is given to your terminal.
119 56
120 57 .. _editors:
121 58
122 59 Editor configuration
123 60 ====================
124 61
125 62 IPython can integrate with text editors in a number of different ways:
126 63
127 64 * Editors (such as `(X)Emacs`_, vim_ and TextMate_) can
128 65 send code to IPython for execution.
129 66
130 67 * IPython's ``%edit`` magic command can open an editor of choice to edit
131 68 a code block.
132 69
133 70 The %edit command (and its alias %ed) will invoke the editor set in your
134 71 environment as :envvar:`EDITOR`. If this variable is not set, it will default
135 72 to vi under Linux/Unix and to notepad under Windows. You may want to set this
136 73 variable properly and to a lightweight editor which doesn't take too long to
137 74 start (that is, something other than a new instance of Emacs). This way you
138 75 can edit multi-line code quickly and with the power of a real editor right
139 76 inside IPython.
140 77
141 78 You can also control the editor by setting :attr:`TerminalInteractiveShell.editor`
142 79 in :file:`ipython_config.py`.
143 80
144 81 Vim
145 82 ---
146 83
147 84 Paul Ivanov's `vim-ipython <https://github.com/ivanov/vim-ipython>`_ provides
148 85 powerful IPython integration for vim.
149 86
150 87 .. _emacs:
151 88
152 89 (X)Emacs
153 90 --------
154 91
155 92 If you are a dedicated Emacs user, and want to use Emacs when IPython's
156 93 ``%edit`` magic command is called you should set up the Emacs server so that
157 94 new requests are handled by the original process. This means that almost no
158 95 time is spent in handling the request (assuming an Emacs process is already
159 96 running). For this to work, you need to set your EDITOR environment variable
160 97 to 'emacsclient'. The code below, supplied by Francois Pinard, can then be
161 98 used in your :file:`.emacs` file to enable the server:
162 99
163 100 .. code-block:: common-lisp
164 101
165 102 (defvar server-buffer-clients)
166 103 (when (and (fboundp 'server-start) (string-equal (getenv "TERM") 'xterm))
167 104 (server-start)
168 105 (defun fp-kill-server-with-buffer-routine ()
169 106 (and server-buffer-clients (server-done)))
170 107 (add-hook 'kill-buffer-hook 'fp-kill-server-with-buffer-routine))
171 108
172 109 Thanks to the work of Alexander Schmolck and Prabhu Ramachandran,
173 110 currently (X)Emacs and IPython get along very well in other ways.
174 111
175 112 With (X)EMacs >= 24, You can enable IPython in python-mode with:
176 113
177 114 .. code-block:: common-lisp
178 115
179 116 (require 'python)
180 117 (setq python-shell-interpreter "ipython")
181 118
182 119 .. _`(X)Emacs`: http://www.gnu.org/software/emacs/
183 120 .. _TextMate: http://macromates.com/
184 121 .. _vim: http://www.vim.org/
@@ -1,158 +1,153 b''
1 1 =====================================
2 2 Introduction to IPython configuration
3 3 =====================================
4 4
5 5 .. _setting_config:
6 6
7 7 Setting configurable options
8 8 ============================
9 9
10 10 Many of IPython's classes have configurable attributes (see
11 11 :doc:`options/index` for the list). These can be
12 12 configured in several ways.
13 13
14 14 Python config files
15 15 -------------------
16 16
17 17 To create the blank config files, run::
18 18
19 19 ipython profile create [profilename]
20 20
21 21 If you leave out the profile name, the files will be created for the
22 22 ``default`` profile (see :ref:`profiles`). These will typically be
23 23 located in :file:`~/.ipython/profile_default/`, and will be named
24 24 :file:`ipython_config.py`, :file:`ipython_notebook_config.py`, etc.
25 25 The settings in :file:`ipython_config.py` apply to all IPython commands.
26 26
27 27 The files typically start by getting the root config object::
28 28
29 29 c = get_config()
30 30
31 31 You can then configure class attributes like this::
32 32
33 33 c.InteractiveShell.automagic = False
34 34
35 35 Be careful with spelling--incorrect names will simply be ignored, with
36 36 no error.
37 37
38 38 To add to a collection which may have already been defined elsewhere,
39 39 you can use methods like those found on lists, dicts and sets: append,
40 40 extend, :meth:`~traitlets.config.LazyConfigValue.prepend` (like
41 41 extend, but at the front), add and update (which works both for dicts
42 42 and sets)::
43 43
44 44 c.InteractiveShellApp.extensions.append('Cython')
45 45
46 46 .. versionadded:: 2.0
47 47 list, dict and set methods for config values
48 48
49 49 Example config file
50 50 ```````````````````
51 51
52 52 ::
53 53
54 54 # sample ipython_config.py
55 55 c = get_config()
56 56
57 57 c.TerminalIPythonApp.display_banner = True
58 58 c.InteractiveShellApp.log_level = 20
59 59 c.InteractiveShellApp.extensions = [
60 60 'myextension'
61 61 ]
62 62 c.InteractiveShellApp.exec_lines = [
63 63 'import numpy',
64 64 'import scipy'
65 65 ]
66 66 c.InteractiveShellApp.exec_files = [
67 67 'mycode.py',
68 68 'fancy.ipy'
69 69 ]
70 70 c.InteractiveShell.autoindent = True
71 71 c.InteractiveShell.colors = 'LightBG'
72 72 c.InteractiveShell.confirm_exit = False
73 73 c.InteractiveShell.editor = 'nano'
74 74 c.InteractiveShell.xmode = 'Context'
75 75
76 c.PromptManager.in_template = 'In [\#]: '
77 c.PromptManager.in2_template = ' .\D.: '
78 c.PromptManager.out_template = 'Out[\#]: '
79 c.PromptManager.justify = True
80
81 76 c.PrefilterManager.multi_line_specials = True
82 77
83 78 c.AliasManager.user_aliases = [
84 79 ('la', 'ls -al')
85 80 ]
86 81
87 82
88 83 Command line arguments
89 84 ----------------------
90 85
91 86 Every configurable value can be set from the command line, using this
92 87 syntax::
93 88
94 89 ipython --ClassName.attribute=value
95 90
96 91 Many frequently used options have short aliases and flags, such as
97 92 ``--matplotlib`` (to integrate with a matplotlib GUI event loop) or
98 93 ``--pdb`` (automatic post-mortem debugging of exceptions).
99 94
100 95 To see all of these abbreviated options, run::
101 96
102 97 ipython --help
103 98 ipython notebook --help
104 99 # etc.
105 100
106 101 Options specified at the command line, in either format, override
107 102 options set in a configuration file.
108 103
109 104 The config magic
110 105 ----------------
111 106
112 107 You can also modify config from inside IPython, using a magic command::
113 108
114 109 %config IPCompleter.greedy = True
115 110
116 111 At present, this only affects the current session - changes you make to
117 112 config are not saved anywhere. Also, some options are only read when
118 113 IPython starts, so they can't be changed like this.
119 114
120 115 .. _profiles:
121 116
122 117 Profiles
123 118 ========
124 119
125 120 IPython can use multiple profiles, with separate configuration and
126 121 history. By default, if you don't specify a profile, IPython always runs
127 122 in the ``default`` profile. To use a new profile::
128 123
129 124 ipython profile create foo # create the profile foo
130 125 ipython --profile=foo # start IPython using the new profile
131 126
132 127 Profiles are typically stored in :ref:`ipythondir`, but you can also keep
133 128 a profile in the current working directory, for example to distribute it
134 129 with a project. To find a profile directory on the filesystem::
135 130
136 131 ipython locate profile foo
137 132
138 133 .. _ipythondir:
139 134
140 135 The IPython directory
141 136 =====================
142 137
143 138 IPython stores its files---config, command history and extensions---in
144 139 the directory :file:`~/.ipython/` by default.
145 140
146 141 .. envvar:: IPYTHONDIR
147 142
148 143 If set, this environment variable should be the path to a directory,
149 144 which IPython will use for user data. IPython will create it if it
150 145 does not exist.
151 146
152 147 .. option:: --ipython-dir=<path>
153 148
154 149 This command line option can also be used to override the default
155 150 IPython directory.
156 151
157 152 To see where IPython is looking for the IPython directory, use the command
158 153 ``ipython locate``, or the Python function :func:`IPython.paths.get_ipython_dir`.
@@ -1,213 +1,239 b''
1 1 .. _ipython_as_shell:
2 2
3 3 =========================
4 4 IPython as a system shell
5 5 =========================
6 6
7 7
8 8
9 9 Overview
10 10 ========
11 11
12 12 It is possible to adapt IPython for system shell usage. In the past, IPython
13 13 shipped a special 'sh' profile for this purpose, but it had been quarantined
14 14 since 0.11 release, and in 1.0 it was removed altogether. Nevertheless, much
15 15 of this section relies on machinery which does not require a custom profile.
16 16
17 17 You can set up your own 'sh' :ref:`profile <Profiles>` to be different from
18 18 the default profile such that:
19 19
20 20 * Prompt shows the current directory (see `Prompt customization`_)
21 21 * Make system commands directly available (in alias table) by running the
22 22 ``%rehashx`` magic. If you install new programs along your PATH, you might
23 23 want to run ``%rehashx`` to update the alias table
24 24 * turn ``%autocall`` to full mode
25 25
26 26
27 27 Environment variables
28 28 =====================
29 29
30 30 Rather than manipulating os.environ directly, you may like to use the magic
31 31 `%env` command. With no arguments, this displays all environment variables
32 32 and values. To get the value of a specific variable, use `%env var`. To set
33 33 the value of a specific variable, use `%env foo bar`, `%env foo=bar`. By
34 34 default values are considered to be strings so quoting them is unnecessary.
35 35 However, Python variables are expanded as usual in the magic command, so
36 36 `%env foo=$bar` means "set the environment variable foo to the value of the
37 37 Python variable `bar`".
38 38
39 39 Aliases
40 40 =======
41 41
42 42 Once you run ``%rehashx``, all of your $PATH has been loaded as IPython aliases,
43 43 so you should be able to type any normal system command and have it executed.
44 44 See ``%alias?`` and ``%unalias?`` for details on the alias facilities. See also
45 45 ``%rehashx?`` for details on the mechanism used to load $PATH.
46 46
47 47
48 48 Directory management
49 49 ====================
50 50
51 51 Since each command passed by IPython to the underlying system is executed
52 52 in a subshell which exits immediately, you can NOT use !cd to navigate
53 53 the filesystem.
54 54
55 55 IPython provides its own builtin ``%cd`` magic command to move in the
56 56 filesystem (the % is not required with automagic on). It also maintains
57 57 a list of visited directories (use ``%dhist`` to see it) and allows direct
58 58 switching to any of them. Type ``cd?`` for more details.
59 59
60 60 ``%pushd``, ``%popd`` and ``%dirs`` are provided for directory stack handling.
61 61
62 62
63 63 Prompt customization
64 64 ====================
65 65
66 Here are some prompt configurations you can try out interactively by using the
67 ``%config`` magic::
68
69 %config PromptManager.in_template = r'{color.LightGreen}\u@\h{color.LightBlue}[{color.LightCyan}\Y1{color.LightBlue}]{color.Green}|\#> '
70 %config PromptManager.in2_template = r'{color.Green}|{color.LightGreen}\D{color.Green}> '
71 %config PromptManager.out_template = r'<\#> '
72
73
74 You can change the prompt configuration to your liking permanently by editing
75 ``ipython_config.py``::
76
77 c.PromptManager.in_template = r'{color.LightGreen}\u@\h{color.LightBlue}[{color.LightCyan}\Y1{color.LightBlue}]{color.Green}|\#> '
78 c.PromptManager.in2_template = r'{color.Green}|{color.LightGreen}\D{color.Green}> '
79 c.PromptManager.out_template = r'<\#> '
66 Starting at IPython 5.0 the prompt customisation is done by subclassing :class:`IPython.terminal.prompts.Prompt`.
67
68 The custom ``Prompt`` receive the current IPython shell instance as first
69 argument, which by default is stored as the ``shell`` attribute of the object.
70 The class can implement optional methods for each of the available prompt types:
71
72 - ``in_prompt_tokens(self, cli=None)``, input prompt , default to ``In [1]``
73 - ``continuation_prompt_tokens(self, cli=None, width=None)``, continuation prompt for multi lines (default `...:`)
74 - ``rewrite_prompt_tokens(self)``
75 - ``out_prompt_tokens(self)``
76
77 Each of these methods should return a list of `(TokenType, Token)` pairs. See documentation of `prompt_toolkit` and/or `Pygments`.
78
79 Here is an example of Prompt class that will insert the current working directory in front of a prompt:
80
81
82 .. codeblock:: python
83
84 from IPython.terminal.prompts import Prompts, Token
85 import os
86
87 class MyPrompt(Prompts):
88
89 def in_prompt_tokens(self, cli=None):
90 return [(Token, os.getcwd()),
91 (Token.Prompt, ' >>>')]
92
93 To set the new prompt, assign it to the `prompts` attribute of the IPython shell:
94
95 .. codeblock:: python
96
97 In[2]: ip = get_ipython()
98 ...: ip.prompts = MyPrompt(ip)
99
100 ~/ >>> # it works
101
102
103 See ``IPython/example/utils/cwd_prompt.py`` for an example of how to write an
104 extensions that customise prompts.
105
80 106
81 107 Read more about the :ref:`configuration system <config_overview>` for details
82 108 on how to find ``ipython_config.py``.
83 109
84 110 .. _string_lists:
85 111
86 112 String lists
87 113 ============
88 114
89 115 String lists (IPython.utils.text.SList) are handy way to process output
90 116 from system commands. They are produced by ``var = !cmd`` syntax.
91 117
92 118 First, we acquire the output of 'ls -l'::
93 119
94 120 [Q:doc/examples]|2> lines = !ls -l
95 121 ==
96 122 ['total 23',
97 123 '-rw-rw-rw- 1 ville None 1163 Sep 30 2006 example-demo.py',
98 124 '-rw-rw-rw- 1 ville None 1927 Sep 30 2006 example-embed-short.py',
99 125 '-rwxrwxrwx 1 ville None 4606 Sep 1 17:15 example-embed.py',
100 126 '-rwxrwxrwx 1 ville None 1017 Sep 30 2006 example-gnuplot.py',
101 127 '-rwxrwxrwx 1 ville None 339 Jun 11 18:01 extension.py',
102 128 '-rwxrwxrwx 1 ville None 113 Dec 20 2006 seteditor.py',
103 129 '-rwxrwxrwx 1 ville None 245 Dec 12 2006 seteditor.pyc']
104 130
105 131 Now, let's take a look at the contents of 'lines' (the first number is
106 132 the list element number)::
107 133
108 134 [Q:doc/examples]|3> lines
109 135 <3> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
110 136
111 137 0: total 23
112 138 1: -rw-rw-rw- 1 ville None 1163 Sep 30 2006 example-demo.py
113 139 2: -rw-rw-rw- 1 ville None 1927 Sep 30 2006 example-embed-short.py
114 140 3: -rwxrwxrwx 1 ville None 4606 Sep 1 17:15 example-embed.py
115 141 4: -rwxrwxrwx 1 ville None 1017 Sep 30 2006 example-gnuplot.py
116 142 5: -rwxrwxrwx 1 ville None 339 Jun 11 18:01 extension.py
117 143 6: -rwxrwxrwx 1 ville None 113 Dec 20 2006 seteditor.py
118 144 7: -rwxrwxrwx 1 ville None 245 Dec 12 2006 seteditor.pyc
119 145
120 146 Now, let's filter out the 'embed' lines::
121 147
122 148 [Q:doc/examples]|4> l2 = lines.grep('embed',prune=1)
123 149 [Q:doc/examples]|5> l2
124 150 <5> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
125 151
126 152 0: total 23
127 153 1: -rw-rw-rw- 1 ville None 1163 Sep 30 2006 example-demo.py
128 154 2: -rwxrwxrwx 1 ville None 1017 Sep 30 2006 example-gnuplot.py
129 155 3: -rwxrwxrwx 1 ville None 339 Jun 11 18:01 extension.py
130 156 4: -rwxrwxrwx 1 ville None 113 Dec 20 2006 seteditor.py
131 157 5: -rwxrwxrwx 1 ville None 245 Dec 12 2006 seteditor.pyc
132 158
133 159 Now, we want strings having just file names and permissions::
134 160
135 161 [Q:doc/examples]|6> l2.fields(8,0)
136 162 <6> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
137 163
138 164 0: total
139 165 1: example-demo.py -rw-rw-rw-
140 166 2: example-gnuplot.py -rwxrwxrwx
141 167 3: extension.py -rwxrwxrwx
142 168 4: seteditor.py -rwxrwxrwx
143 169 5: seteditor.pyc -rwxrwxrwx
144 170
145 171 Note how the line with 'total' does not raise IndexError.
146 172
147 173 If you want to split these (yielding lists), call fields() without
148 174 arguments::
149 175
150 176 [Q:doc/examples]|7> _.fields()
151 177 <7>
152 178 [['total'],
153 179 ['example-demo.py', '-rw-rw-rw-'],
154 180 ['example-gnuplot.py', '-rwxrwxrwx'],
155 181 ['extension.py', '-rwxrwxrwx'],
156 182 ['seteditor.py', '-rwxrwxrwx'],
157 183 ['seteditor.pyc', '-rwxrwxrwx']]
158 184
159 185 If you want to pass these separated with spaces to a command (typical
160 186 for lists if files), use the .s property::
161 187
162 188
163 189 [Q:doc/examples]|13> files = l2.fields(8).s
164 190 [Q:doc/examples]|14> files
165 191 <14> 'example-demo.py example-gnuplot.py extension.py seteditor.py seteditor.pyc'
166 192 [Q:doc/examples]|15> ls $files
167 193 example-demo.py example-gnuplot.py extension.py seteditor.py seteditor.pyc
168 194
169 195 SLists are inherited from normal Python lists, so every list method is
170 196 available::
171 197
172 198 [Q:doc/examples]|21> lines.append('hey')
173 199
174 200
175 201 Real world example: remove all files outside version control
176 202 ------------------------------------------------------------
177 203
178 204 First, capture output of "hg status"::
179 205
180 206 [Q:/ipython]|28> out = !hg status
181 207 ==
182 208 ['M IPython\\extensions\\ipy_kitcfg.py',
183 209 'M IPython\\extensions\\ipy_rehashdir.py',
184 210 ...
185 211 '? build\\lib\\IPython\\Debugger.py',
186 212 '? build\\lib\\IPython\\extensions\\InterpreterExec.py',
187 213 '? build\\lib\\IPython\\extensions\\InterpreterPasteInput.py',
188 214 ...
189 215
190 216 (lines starting with ? are not under version control).
191 217
192 218 ::
193 219
194 220 [Q:/ipython]|35> junk = out.grep(r'^\?').fields(1)
195 221 [Q:/ipython]|36> junk
196 222 <36> SList (.p, .n, .l, .s, .grep(), .fields() availab
197 223 ...
198 224 10: build\bdist.win32\winexe\temp\_ctypes.py
199 225 11: build\bdist.win32\winexe\temp\_hashlib.py
200 226 12: build\bdist.win32\winexe\temp\_socket.py
201 227
202 228 Now we can just remove these files by doing 'rm $junk.s'.
203 229
204 230 The .s, .n, .p properties
205 231 -------------------------
206 232
207 233 The ``.s`` property returns one string where lines are separated by
208 234 single space (for convenient passing to system commands). The ``.n``
209 235 property return one string where the lines are separated by a newline
210 236 (i.e. the original output of the function). If the items in string
211 237 list are file names, ``.p`` can be used to get a list of "path" objects
212 238 for convenient file manipulation.
213 239
General Comments 0
You need to be logged in to leave comments. Login now