##// END OF EJS Templates
use system_raw in terminal, even on Windows...
MinRK -
Show More
@@ -1,641 +1,639 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Subclass of InteractiveShell for terminal based frontends."""
2 """Subclass of InteractiveShell for terminal based frontends."""
3
3
4 #-----------------------------------------------------------------------------
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 # Copyright (C) 2008-2010 The IPython Development Team
7 # Copyright (C) 2008-2010 The IPython Development Team
8 #
8 #
9 # Distributed under the terms of the BSD License. The full license is in
9 # Distributed under the terms of the BSD License. The full license is in
10 # the file COPYING, distributed as part of this software.
10 # the file COPYING, distributed as part of this software.
11 #-----------------------------------------------------------------------------
11 #-----------------------------------------------------------------------------
12
12
13 #-----------------------------------------------------------------------------
13 #-----------------------------------------------------------------------------
14 # Imports
14 # Imports
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16
16
17 import __builtin__
17 import __builtin__
18 import bdb
18 import bdb
19 import os
19 import os
20 import re
20 import re
21 import sys
21 import sys
22
22
23 try:
23 try:
24 from contextlib import nested
24 from contextlib import nested
25 except:
25 except:
26 from IPython.utils.nested_context import nested
26 from IPython.utils.nested_context import nested
27
27
28 from IPython.core.error import TryNext
28 from IPython.core.error import TryNext
29 from IPython.core.usage import interactive_usage, default_banner
29 from IPython.core.usage import interactive_usage, default_banner
30 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
30 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
31 from IPython.lib.inputhook import enable_gui
31 from IPython.lib.inputhook import enable_gui
32 from IPython.lib.pylabtools import pylab_activate
32 from IPython.lib.pylabtools import pylab_activate
33 from IPython.testing.skipdoctest import skip_doctest
33 from IPython.testing.skipdoctest import skip_doctest
34 from IPython.utils import py3compat
34 from IPython.utils import py3compat
35 from IPython.utils.terminal import toggle_set_term_title, set_term_title
35 from IPython.utils.terminal import toggle_set_term_title, set_term_title
36 from IPython.utils.process import abbrev_cwd
36 from IPython.utils.process import abbrev_cwd
37 from IPython.utils.warn import warn
37 from IPython.utils.warn import warn
38 from IPython.utils.text import num_ini_spaces
38 from IPython.utils.text import num_ini_spaces
39 from IPython.utils.traitlets import Int, CBool, Unicode
39 from IPython.utils.traitlets import Int, CBool, Unicode
40
40
41 #-----------------------------------------------------------------------------
41 #-----------------------------------------------------------------------------
42 # Utilities
42 # Utilities
43 #-----------------------------------------------------------------------------
43 #-----------------------------------------------------------------------------
44
44
45 def get_default_editor():
45 def get_default_editor():
46 try:
46 try:
47 ed = os.environ['EDITOR']
47 ed = os.environ['EDITOR']
48 except KeyError:
48 except KeyError:
49 if os.name == 'posix':
49 if os.name == 'posix':
50 ed = 'vi' # the only one guaranteed to be there!
50 ed = 'vi' # the only one guaranteed to be there!
51 else:
51 else:
52 ed = 'notepad' # same in Windows!
52 ed = 'notepad' # same in Windows!
53 return ed
53 return ed
54
54
55 #-----------------------------------------------------------------------------
55 #-----------------------------------------------------------------------------
56 # Main class
56 # Main class
57 #-----------------------------------------------------------------------------
57 #-----------------------------------------------------------------------------
58
58
59 class TerminalInteractiveShell(InteractiveShell):
59 class TerminalInteractiveShell(InteractiveShell):
60
60
61 autoedit_syntax = CBool(False, config=True,
61 autoedit_syntax = CBool(False, config=True,
62 help="auto editing of files with syntax errors.")
62 help="auto editing of files with syntax errors.")
63 banner = Unicode('')
63 banner = Unicode('')
64 banner1 = Unicode(default_banner, config=True,
64 banner1 = Unicode(default_banner, config=True,
65 help="""The part of the banner to be printed before the profile"""
65 help="""The part of the banner to be printed before the profile"""
66 )
66 )
67 banner2 = Unicode('', config=True,
67 banner2 = Unicode('', config=True,
68 help="""The part of the banner to be printed after the profile"""
68 help="""The part of the banner to be printed after the profile"""
69 )
69 )
70 confirm_exit = CBool(True, config=True,
70 confirm_exit = CBool(True, config=True,
71 help="""
71 help="""
72 Set to confirm when you try to exit IPython with an EOF (Control-D
72 Set to confirm when you try to exit IPython with an EOF (Control-D
73 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
73 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
74 you can force a direct exit without any confirmation.""",
74 you can force a direct exit without any confirmation.""",
75 )
75 )
76 # This display_banner only controls whether or not self.show_banner()
76 # This display_banner only controls whether or not self.show_banner()
77 # is called when mainloop/interact are called. The default is False
77 # is called when mainloop/interact are called. The default is False
78 # because for the terminal based application, the banner behavior
78 # because for the terminal based application, the banner behavior
79 # is controlled by Global.display_banner, which IPythonApp looks at
79 # is controlled by Global.display_banner, which IPythonApp looks at
80 # to determine if *it* should call show_banner() by hand or not.
80 # to determine if *it* should call show_banner() by hand or not.
81 display_banner = CBool(False) # This isn't configurable!
81 display_banner = CBool(False) # This isn't configurable!
82 embedded = CBool(False)
82 embedded = CBool(False)
83 embedded_active = CBool(False)
83 embedded_active = CBool(False)
84 editor = Unicode(get_default_editor(), config=True,
84 editor = Unicode(get_default_editor(), config=True,
85 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
85 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
86 )
86 )
87 pager = Unicode('less', config=True,
87 pager = Unicode('less', config=True,
88 help="The shell program to be used for paging.")
88 help="The shell program to be used for paging.")
89
89
90 screen_length = Int(0, config=True,
90 screen_length = Int(0, config=True,
91 help=
91 help=
92 """Number of lines of your screen, used to control printing of very
92 """Number of lines of your screen, used to control printing of very
93 long strings. Strings longer than this number of lines will be sent
93 long strings. Strings longer than this number of lines will be sent
94 through a pager instead of directly printed. The default value for
94 through a pager instead of directly printed. The default value for
95 this is 0, which means IPython will auto-detect your screen size every
95 this is 0, which means IPython will auto-detect your screen size every
96 time it needs to print certain potentially long strings (this doesn't
96 time it needs to print certain potentially long strings (this doesn't
97 change the behavior of the 'print' keyword, it's only triggered
97 change the behavior of the 'print' keyword, it's only triggered
98 internally). If for some reason this isn't working well (it needs
98 internally). If for some reason this isn't working well (it needs
99 curses support), specify it yourself. Otherwise don't change the
99 curses support), specify it yourself. Otherwise don't change the
100 default.""",
100 default.""",
101 )
101 )
102 term_title = CBool(False, config=True,
102 term_title = CBool(False, config=True,
103 help="Enable auto setting the terminal title."
103 help="Enable auto setting the terminal title."
104 )
104 )
105
105
106 def __init__(self, config=None, ipython_dir=None, profile_dir=None, user_ns=None,
106 def __init__(self, config=None, ipython_dir=None, profile_dir=None, user_ns=None,
107 user_global_ns=None, custom_exceptions=((),None),
107 user_global_ns=None, custom_exceptions=((),None),
108 usage=None, banner1=None, banner2=None,
108 usage=None, banner1=None, banner2=None,
109 display_banner=None):
109 display_banner=None):
110
110
111 super(TerminalInteractiveShell, self).__init__(
111 super(TerminalInteractiveShell, self).__init__(
112 config=config, profile_dir=profile_dir, user_ns=user_ns,
112 config=config, profile_dir=profile_dir, user_ns=user_ns,
113 user_global_ns=user_global_ns, custom_exceptions=custom_exceptions
113 user_global_ns=user_global_ns, custom_exceptions=custom_exceptions
114 )
114 )
115 # use os.system instead of utils.process.system by default, except on Windows
115 # use os.system instead of utils.process.system by default,
116 if os.name == 'nt':
116 # because piped system doesn't make sense in the Terminal:
117 self.system = self.system_piped
118 else:
119 self.system = self.system_raw
117 self.system = self.system_raw
120
118
121 self.init_term_title()
119 self.init_term_title()
122 self.init_usage(usage)
120 self.init_usage(usage)
123 self.init_banner(banner1, banner2, display_banner)
121 self.init_banner(banner1, banner2, display_banner)
124
122
125 #-------------------------------------------------------------------------
123 #-------------------------------------------------------------------------
126 # Things related to the terminal
124 # Things related to the terminal
127 #-------------------------------------------------------------------------
125 #-------------------------------------------------------------------------
128
126
129 @property
127 @property
130 def usable_screen_length(self):
128 def usable_screen_length(self):
131 if self.screen_length == 0:
129 if self.screen_length == 0:
132 return 0
130 return 0
133 else:
131 else:
134 num_lines_bot = self.separate_in.count('\n')+1
132 num_lines_bot = self.separate_in.count('\n')+1
135 return self.screen_length - num_lines_bot
133 return self.screen_length - num_lines_bot
136
134
137 def init_term_title(self):
135 def init_term_title(self):
138 # Enable or disable the terminal title.
136 # Enable or disable the terminal title.
139 if self.term_title:
137 if self.term_title:
140 toggle_set_term_title(True)
138 toggle_set_term_title(True)
141 set_term_title('IPython: ' + abbrev_cwd())
139 set_term_title('IPython: ' + abbrev_cwd())
142 else:
140 else:
143 toggle_set_term_title(False)
141 toggle_set_term_title(False)
144
142
145 #-------------------------------------------------------------------------
143 #-------------------------------------------------------------------------
146 # Things related to aliases
144 # Things related to aliases
147 #-------------------------------------------------------------------------
145 #-------------------------------------------------------------------------
148
146
149 def init_alias(self):
147 def init_alias(self):
150 # The parent class defines aliases that can be safely used with any
148 # The parent class defines aliases that can be safely used with any
151 # frontend.
149 # frontend.
152 super(TerminalInteractiveShell, self).init_alias()
150 super(TerminalInteractiveShell, self).init_alias()
153
151
154 # Now define aliases that only make sense on the terminal, because they
152 # Now define aliases that only make sense on the terminal, because they
155 # need direct access to the console in a way that we can't emulate in
153 # need direct access to the console in a way that we can't emulate in
156 # GUI or web frontend
154 # GUI or web frontend
157 if os.name == 'posix':
155 if os.name == 'posix':
158 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
156 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
159 ('man', 'man')]
157 ('man', 'man')]
160 elif os.name == 'nt':
158 elif os.name == 'nt':
161 aliases = [('cls', 'cls')]
159 aliases = [('cls', 'cls')]
162
160
163
161
164 for name, cmd in aliases:
162 for name, cmd in aliases:
165 self.alias_manager.define_alias(name, cmd)
163 self.alias_manager.define_alias(name, cmd)
166
164
167 #-------------------------------------------------------------------------
165 #-------------------------------------------------------------------------
168 # Things related to the banner and usage
166 # Things related to the banner and usage
169 #-------------------------------------------------------------------------
167 #-------------------------------------------------------------------------
170
168
171 def _banner1_changed(self):
169 def _banner1_changed(self):
172 self.compute_banner()
170 self.compute_banner()
173
171
174 def _banner2_changed(self):
172 def _banner2_changed(self):
175 self.compute_banner()
173 self.compute_banner()
176
174
177 def _term_title_changed(self, name, new_value):
175 def _term_title_changed(self, name, new_value):
178 self.init_term_title()
176 self.init_term_title()
179
177
180 def init_banner(self, banner1, banner2, display_banner):
178 def init_banner(self, banner1, banner2, display_banner):
181 if banner1 is not None:
179 if banner1 is not None:
182 self.banner1 = banner1
180 self.banner1 = banner1
183 if banner2 is not None:
181 if banner2 is not None:
184 self.banner2 = banner2
182 self.banner2 = banner2
185 if display_banner is not None:
183 if display_banner is not None:
186 self.display_banner = display_banner
184 self.display_banner = display_banner
187 self.compute_banner()
185 self.compute_banner()
188
186
189 def show_banner(self, banner=None):
187 def show_banner(self, banner=None):
190 if banner is None:
188 if banner is None:
191 banner = self.banner
189 banner = self.banner
192 self.write(banner)
190 self.write(banner)
193
191
194 def compute_banner(self):
192 def compute_banner(self):
195 self.banner = self.banner1
193 self.banner = self.banner1
196 if self.profile and self.profile != 'default':
194 if self.profile and self.profile != 'default':
197 self.banner += '\nIPython profile: %s\n' % self.profile
195 self.banner += '\nIPython profile: %s\n' % self.profile
198 if self.banner2:
196 if self.banner2:
199 self.banner += '\n' + self.banner2
197 self.banner += '\n' + self.banner2
200
198
201 def init_usage(self, usage=None):
199 def init_usage(self, usage=None):
202 if usage is None:
200 if usage is None:
203 self.usage = interactive_usage
201 self.usage = interactive_usage
204 else:
202 else:
205 self.usage = usage
203 self.usage = usage
206
204
207 #-------------------------------------------------------------------------
205 #-------------------------------------------------------------------------
208 # Mainloop and code execution logic
206 # Mainloop and code execution logic
209 #-------------------------------------------------------------------------
207 #-------------------------------------------------------------------------
210
208
211 def mainloop(self, display_banner=None):
209 def mainloop(self, display_banner=None):
212 """Start the mainloop.
210 """Start the mainloop.
213
211
214 If an optional banner argument is given, it will override the
212 If an optional banner argument is given, it will override the
215 internally created default banner.
213 internally created default banner.
216 """
214 """
217
215
218 with nested(self.builtin_trap, self.display_trap):
216 with nested(self.builtin_trap, self.display_trap):
219
217
220 while 1:
218 while 1:
221 try:
219 try:
222 self.interact(display_banner=display_banner)
220 self.interact(display_banner=display_banner)
223 #self.interact_with_readline()
221 #self.interact_with_readline()
224 # XXX for testing of a readline-decoupled repl loop, call
222 # XXX for testing of a readline-decoupled repl loop, call
225 # interact_with_readline above
223 # interact_with_readline above
226 break
224 break
227 except KeyboardInterrupt:
225 except KeyboardInterrupt:
228 # this should not be necessary, but KeyboardInterrupt
226 # this should not be necessary, but KeyboardInterrupt
229 # handling seems rather unpredictable...
227 # handling seems rather unpredictable...
230 self.write("\nKeyboardInterrupt in interact()\n")
228 self.write("\nKeyboardInterrupt in interact()\n")
231
229
232 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
230 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
233 """Store multiple lines as a single entry in history"""
231 """Store multiple lines as a single entry in history"""
234
232
235 # do nothing without readline or disabled multiline
233 # do nothing without readline or disabled multiline
236 if not self.has_readline or not self.multiline_history:
234 if not self.has_readline or not self.multiline_history:
237 return hlen_before_cell
235 return hlen_before_cell
238
236
239 # windows rl has no remove_history_item
237 # windows rl has no remove_history_item
240 if not hasattr(self.readline, "remove_history_item"):
238 if not hasattr(self.readline, "remove_history_item"):
241 return hlen_before_cell
239 return hlen_before_cell
242
240
243 # skip empty cells
241 # skip empty cells
244 if not source_raw.rstrip():
242 if not source_raw.rstrip():
245 return hlen_before_cell
243 return hlen_before_cell
246
244
247 # nothing changed do nothing, e.g. when rl removes consecutive dups
245 # nothing changed do nothing, e.g. when rl removes consecutive dups
248 hlen = self.readline.get_current_history_length()
246 hlen = self.readline.get_current_history_length()
249 if hlen == hlen_before_cell:
247 if hlen == hlen_before_cell:
250 return hlen_before_cell
248 return hlen_before_cell
251
249
252 for i in range(hlen - hlen_before_cell):
250 for i in range(hlen - hlen_before_cell):
253 self.readline.remove_history_item(hlen - i - 1)
251 self.readline.remove_history_item(hlen - i - 1)
254 stdin_encoding = sys.stdin.encoding or "utf-8"
252 stdin_encoding = sys.stdin.encoding or "utf-8"
255 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
253 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
256 stdin_encoding))
254 stdin_encoding))
257 return self.readline.get_current_history_length()
255 return self.readline.get_current_history_length()
258
256
259 def interact(self, display_banner=None):
257 def interact(self, display_banner=None):
260 """Closely emulate the interactive Python console."""
258 """Closely emulate the interactive Python console."""
261
259
262 # batch run -> do not interact
260 # batch run -> do not interact
263 if self.exit_now:
261 if self.exit_now:
264 return
262 return
265
263
266 if display_banner is None:
264 if display_banner is None:
267 display_banner = self.display_banner
265 display_banner = self.display_banner
268
266
269 if isinstance(display_banner, basestring):
267 if isinstance(display_banner, basestring):
270 self.show_banner(display_banner)
268 self.show_banner(display_banner)
271 elif display_banner:
269 elif display_banner:
272 self.show_banner()
270 self.show_banner()
273
271
274 more = False
272 more = False
275
273
276 # Mark activity in the builtins
274 # Mark activity in the builtins
277 __builtin__.__dict__['__IPYTHON__active'] += 1
275 __builtin__.__dict__['__IPYTHON__active'] += 1
278
276
279 if self.has_readline:
277 if self.has_readline:
280 self.readline_startup_hook(self.pre_readline)
278 self.readline_startup_hook(self.pre_readline)
281 hlen_b4_cell = self.readline.get_current_history_length()
279 hlen_b4_cell = self.readline.get_current_history_length()
282 else:
280 else:
283 hlen_b4_cell = 0
281 hlen_b4_cell = 0
284 # exit_now is set by a call to %Exit or %Quit, through the
282 # exit_now is set by a call to %Exit or %Quit, through the
285 # ask_exit callback.
283 # ask_exit callback.
286
284
287 while not self.exit_now:
285 while not self.exit_now:
288 self.hooks.pre_prompt_hook()
286 self.hooks.pre_prompt_hook()
289 if more:
287 if more:
290 try:
288 try:
291 prompt = self.hooks.generate_prompt(True)
289 prompt = self.hooks.generate_prompt(True)
292 except:
290 except:
293 self.showtraceback()
291 self.showtraceback()
294 if self.autoindent:
292 if self.autoindent:
295 self.rl_do_indent = True
293 self.rl_do_indent = True
296
294
297 else:
295 else:
298 try:
296 try:
299 prompt = self.hooks.generate_prompt(False)
297 prompt = self.hooks.generate_prompt(False)
300 except:
298 except:
301 self.showtraceback()
299 self.showtraceback()
302 try:
300 try:
303 line = self.raw_input(prompt)
301 line = self.raw_input(prompt)
304 if self.exit_now:
302 if self.exit_now:
305 # quick exit on sys.std[in|out] close
303 # quick exit on sys.std[in|out] close
306 break
304 break
307 if self.autoindent:
305 if self.autoindent:
308 self.rl_do_indent = False
306 self.rl_do_indent = False
309
307
310 except KeyboardInterrupt:
308 except KeyboardInterrupt:
311 #double-guard against keyboardinterrupts during kbdint handling
309 #double-guard against keyboardinterrupts during kbdint handling
312 try:
310 try:
313 self.write('\nKeyboardInterrupt\n')
311 self.write('\nKeyboardInterrupt\n')
314 source_raw = self.input_splitter.source_raw_reset()[1]
312 source_raw = self.input_splitter.source_raw_reset()[1]
315 hlen_b4_cell = \
313 hlen_b4_cell = \
316 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
314 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
317 more = False
315 more = False
318 except KeyboardInterrupt:
316 except KeyboardInterrupt:
319 pass
317 pass
320 except EOFError:
318 except EOFError:
321 if self.autoindent:
319 if self.autoindent:
322 self.rl_do_indent = False
320 self.rl_do_indent = False
323 if self.has_readline:
321 if self.has_readline:
324 self.readline_startup_hook(None)
322 self.readline_startup_hook(None)
325 self.write('\n')
323 self.write('\n')
326 self.exit()
324 self.exit()
327 except bdb.BdbQuit:
325 except bdb.BdbQuit:
328 warn('The Python debugger has exited with a BdbQuit exception.\n'
326 warn('The Python debugger has exited with a BdbQuit exception.\n'
329 'Because of how pdb handles the stack, it is impossible\n'
327 'Because of how pdb handles the stack, it is impossible\n'
330 'for IPython to properly format this particular exception.\n'
328 'for IPython to properly format this particular exception.\n'
331 'IPython will resume normal operation.')
329 'IPython will resume normal operation.')
332 except:
330 except:
333 # exceptions here are VERY RARE, but they can be triggered
331 # exceptions here are VERY RARE, but they can be triggered
334 # asynchronously by signal handlers, for example.
332 # asynchronously by signal handlers, for example.
335 self.showtraceback()
333 self.showtraceback()
336 else:
334 else:
337 self.input_splitter.push(line)
335 self.input_splitter.push(line)
338 more = self.input_splitter.push_accepts_more()
336 more = self.input_splitter.push_accepts_more()
339 if (self.SyntaxTB.last_syntax_error and
337 if (self.SyntaxTB.last_syntax_error and
340 self.autoedit_syntax):
338 self.autoedit_syntax):
341 self.edit_syntax_error()
339 self.edit_syntax_error()
342 if not more:
340 if not more:
343 source_raw = self.input_splitter.source_raw_reset()[1]
341 source_raw = self.input_splitter.source_raw_reset()[1]
344 self.run_cell(source_raw, store_history=True)
342 self.run_cell(source_raw, store_history=True)
345 hlen_b4_cell = \
343 hlen_b4_cell = \
346 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
344 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
347
345
348 # We are off again...
346 # We are off again...
349 __builtin__.__dict__['__IPYTHON__active'] -= 1
347 __builtin__.__dict__['__IPYTHON__active'] -= 1
350
348
351 # Turn off the exit flag, so the mainloop can be restarted if desired
349 # Turn off the exit flag, so the mainloop can be restarted if desired
352 self.exit_now = False
350 self.exit_now = False
353
351
354 def raw_input(self, prompt=''):
352 def raw_input(self, prompt=''):
355 """Write a prompt and read a line.
353 """Write a prompt and read a line.
356
354
357 The returned line does not include the trailing newline.
355 The returned line does not include the trailing newline.
358 When the user enters the EOF key sequence, EOFError is raised.
356 When the user enters the EOF key sequence, EOFError is raised.
359
357
360 Optional inputs:
358 Optional inputs:
361
359
362 - prompt(''): a string to be printed to prompt the user.
360 - prompt(''): a string to be printed to prompt the user.
363
361
364 - continue_prompt(False): whether this line is the first one or a
362 - continue_prompt(False): whether this line is the first one or a
365 continuation in a sequence of inputs.
363 continuation in a sequence of inputs.
366 """
364 """
367 # Code run by the user may have modified the readline completer state.
365 # Code run by the user may have modified the readline completer state.
368 # We must ensure that our completer is back in place.
366 # We must ensure that our completer is back in place.
369
367
370 if self.has_readline:
368 if self.has_readline:
371 self.set_readline_completer()
369 self.set_readline_completer()
372
370
373 try:
371 try:
374 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
372 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
375 except ValueError:
373 except ValueError:
376 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
374 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
377 " or sys.stdout.close()!\nExiting IPython!")
375 " or sys.stdout.close()!\nExiting IPython!")
378 self.ask_exit()
376 self.ask_exit()
379 return ""
377 return ""
380
378
381 # Try to be reasonably smart about not re-indenting pasted input more
379 # Try to be reasonably smart about not re-indenting pasted input more
382 # than necessary. We do this by trimming out the auto-indent initial
380 # than necessary. We do this by trimming out the auto-indent initial
383 # spaces, if the user's actual input started itself with whitespace.
381 # spaces, if the user's actual input started itself with whitespace.
384 if self.autoindent:
382 if self.autoindent:
385 if num_ini_spaces(line) > self.indent_current_nsp:
383 if num_ini_spaces(line) > self.indent_current_nsp:
386 line = line[self.indent_current_nsp:]
384 line = line[self.indent_current_nsp:]
387 self.indent_current_nsp = 0
385 self.indent_current_nsp = 0
388
386
389 return line
387 return line
390
388
391 #-------------------------------------------------------------------------
389 #-------------------------------------------------------------------------
392 # Methods to support auto-editing of SyntaxErrors.
390 # Methods to support auto-editing of SyntaxErrors.
393 #-------------------------------------------------------------------------
391 #-------------------------------------------------------------------------
394
392
395 def edit_syntax_error(self):
393 def edit_syntax_error(self):
396 """The bottom half of the syntax error handler called in the main loop.
394 """The bottom half of the syntax error handler called in the main loop.
397
395
398 Loop until syntax error is fixed or user cancels.
396 Loop until syntax error is fixed or user cancels.
399 """
397 """
400
398
401 while self.SyntaxTB.last_syntax_error:
399 while self.SyntaxTB.last_syntax_error:
402 # copy and clear last_syntax_error
400 # copy and clear last_syntax_error
403 err = self.SyntaxTB.clear_err_state()
401 err = self.SyntaxTB.clear_err_state()
404 if not self._should_recompile(err):
402 if not self._should_recompile(err):
405 return
403 return
406 try:
404 try:
407 # may set last_syntax_error again if a SyntaxError is raised
405 # may set last_syntax_error again if a SyntaxError is raised
408 self.safe_execfile(err.filename,self.user_ns)
406 self.safe_execfile(err.filename,self.user_ns)
409 except:
407 except:
410 self.showtraceback()
408 self.showtraceback()
411 else:
409 else:
412 try:
410 try:
413 f = file(err.filename)
411 f = file(err.filename)
414 try:
412 try:
415 # This should be inside a display_trap block and I
413 # This should be inside a display_trap block and I
416 # think it is.
414 # think it is.
417 sys.displayhook(f.read())
415 sys.displayhook(f.read())
418 finally:
416 finally:
419 f.close()
417 f.close()
420 except:
418 except:
421 self.showtraceback()
419 self.showtraceback()
422
420
423 def _should_recompile(self,e):
421 def _should_recompile(self,e):
424 """Utility routine for edit_syntax_error"""
422 """Utility routine for edit_syntax_error"""
425
423
426 if e.filename in ('<ipython console>','<input>','<string>',
424 if e.filename in ('<ipython console>','<input>','<string>',
427 '<console>','<BackgroundJob compilation>',
425 '<console>','<BackgroundJob compilation>',
428 None):
426 None):
429
427
430 return False
428 return False
431 try:
429 try:
432 if (self.autoedit_syntax and
430 if (self.autoedit_syntax and
433 not self.ask_yes_no('Return to editor to correct syntax error? '
431 not self.ask_yes_no('Return to editor to correct syntax error? '
434 '[Y/n] ','y')):
432 '[Y/n] ','y')):
435 return False
433 return False
436 except EOFError:
434 except EOFError:
437 return False
435 return False
438
436
439 def int0(x):
437 def int0(x):
440 try:
438 try:
441 return int(x)
439 return int(x)
442 except TypeError:
440 except TypeError:
443 return 0
441 return 0
444 # always pass integer line and offset values to editor hook
442 # always pass integer line and offset values to editor hook
445 try:
443 try:
446 self.hooks.fix_error_editor(e.filename,
444 self.hooks.fix_error_editor(e.filename,
447 int0(e.lineno),int0(e.offset),e.msg)
445 int0(e.lineno),int0(e.offset),e.msg)
448 except TryNext:
446 except TryNext:
449 warn('Could not open editor')
447 warn('Could not open editor')
450 return False
448 return False
451 return True
449 return True
452
450
453 #-------------------------------------------------------------------------
451 #-------------------------------------------------------------------------
454 # Things related to GUI support and pylab
452 # Things related to GUI support and pylab
455 #-------------------------------------------------------------------------
453 #-------------------------------------------------------------------------
456
454
457 def enable_pylab(self, gui=None, import_all=True):
455 def enable_pylab(self, gui=None, import_all=True):
458 """Activate pylab support at runtime.
456 """Activate pylab support at runtime.
459
457
460 This turns on support for matplotlib, preloads into the interactive
458 This turns on support for matplotlib, preloads into the interactive
461 namespace all of numpy and pylab, and configures IPython to correcdtly
459 namespace all of numpy and pylab, and configures IPython to correcdtly
462 interact with the GUI event loop. The GUI backend to be used can be
460 interact with the GUI event loop. The GUI backend to be used can be
463 optionally selected with the optional :param:`gui` argument.
461 optionally selected with the optional :param:`gui` argument.
464
462
465 Parameters
463 Parameters
466 ----------
464 ----------
467 gui : optional, string
465 gui : optional, string
468
466
469 If given, dictates the choice of matplotlib GUI backend to use
467 If given, dictates the choice of matplotlib GUI backend to use
470 (should be one of IPython's supported backends, 'tk', 'qt', 'wx' or
468 (should be one of IPython's supported backends, 'tk', 'qt', 'wx' or
471 'gtk'), otherwise we use the default chosen by matplotlib (as
469 'gtk'), otherwise we use the default chosen by matplotlib (as
472 dictated by the matplotlib build-time options plus the user's
470 dictated by the matplotlib build-time options plus the user's
473 matplotlibrc configuration file).
471 matplotlibrc configuration file).
474 """
472 """
475 # We want to prevent the loading of pylab to pollute the user's
473 # We want to prevent the loading of pylab to pollute the user's
476 # namespace as shown by the %who* magics, so we execute the activation
474 # namespace as shown by the %who* magics, so we execute the activation
477 # code in an empty namespace, and we update *both* user_ns and
475 # code in an empty namespace, and we update *both* user_ns and
478 # user_ns_hidden with this information.
476 # user_ns_hidden with this information.
479 ns = {}
477 ns = {}
480 try:
478 try:
481 gui = pylab_activate(ns, gui, import_all)
479 gui = pylab_activate(ns, gui, import_all)
482 except KeyError:
480 except KeyError:
483 error("Backend %r not supported" % gui)
481 error("Backend %r not supported" % gui)
484 return
482 return
485 self.user_ns.update(ns)
483 self.user_ns.update(ns)
486 self.user_ns_hidden.update(ns)
484 self.user_ns_hidden.update(ns)
487 # Now we must activate the gui pylab wants to use, and fix %run to take
485 # Now we must activate the gui pylab wants to use, and fix %run to take
488 # plot updates into account
486 # plot updates into account
489 enable_gui(gui)
487 enable_gui(gui)
490 self.magic_run = self._pylab_magic_run
488 self.magic_run = self._pylab_magic_run
491
489
492 #-------------------------------------------------------------------------
490 #-------------------------------------------------------------------------
493 # Things related to exiting
491 # Things related to exiting
494 #-------------------------------------------------------------------------
492 #-------------------------------------------------------------------------
495
493
496 def ask_exit(self):
494 def ask_exit(self):
497 """ Ask the shell to exit. Can be overiden and used as a callback. """
495 """ Ask the shell to exit. Can be overiden and used as a callback. """
498 self.exit_now = True
496 self.exit_now = True
499
497
500 def exit(self):
498 def exit(self):
501 """Handle interactive exit.
499 """Handle interactive exit.
502
500
503 This method calls the ask_exit callback."""
501 This method calls the ask_exit callback."""
504 if self.confirm_exit:
502 if self.confirm_exit:
505 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
503 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
506 self.ask_exit()
504 self.ask_exit()
507 else:
505 else:
508 self.ask_exit()
506 self.ask_exit()
509
507
510 #------------------------------------------------------------------------
508 #------------------------------------------------------------------------
511 # Magic overrides
509 # Magic overrides
512 #------------------------------------------------------------------------
510 #------------------------------------------------------------------------
513 # Once the base class stops inheriting from magic, this code needs to be
511 # Once the base class stops inheriting from magic, this code needs to be
514 # moved into a separate machinery as well. For now, at least isolate here
512 # moved into a separate machinery as well. For now, at least isolate here
515 # the magics which this class needs to implement differently from the base
513 # the magics which this class needs to implement differently from the base
516 # class, or that are unique to it.
514 # class, or that are unique to it.
517
515
518 def magic_autoindent(self, parameter_s = ''):
516 def magic_autoindent(self, parameter_s = ''):
519 """Toggle autoindent on/off (if available)."""
517 """Toggle autoindent on/off (if available)."""
520
518
521 self.shell.set_autoindent()
519 self.shell.set_autoindent()
522 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
520 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
523
521
524 @skip_doctest
522 @skip_doctest
525 def magic_cpaste(self, parameter_s=''):
523 def magic_cpaste(self, parameter_s=''):
526 """Paste & execute a pre-formatted code block from clipboard.
524 """Paste & execute a pre-formatted code block from clipboard.
527
525
528 You must terminate the block with '--' (two minus-signs) or Ctrl-D alone on the
526 You must terminate the block with '--' (two minus-signs) or Ctrl-D alone on the
529 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
527 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
530 is the new sentinel for this operation)
528 is the new sentinel for this operation)
531
529
532 The block is dedented prior to execution to enable execution of method
530 The block is dedented prior to execution to enable execution of method
533 definitions. '>' and '+' characters at the beginning of a line are
531 definitions. '>' and '+' characters at the beginning of a line are
534 ignored, to allow pasting directly from e-mails, diff files and
532 ignored, to allow pasting directly from e-mails, diff files and
535 doctests (the '...' continuation prompt is also stripped). The
533 doctests (the '...' continuation prompt is also stripped). The
536 executed block is also assigned to variable named 'pasted_block' for
534 executed block is also assigned to variable named 'pasted_block' for
537 later editing with '%edit pasted_block'.
535 later editing with '%edit pasted_block'.
538
536
539 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
537 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
540 This assigns the pasted block to variable 'foo' as string, without
538 This assigns the pasted block to variable 'foo' as string, without
541 dedenting or executing it (preceding >>> and + is still stripped)
539 dedenting or executing it (preceding >>> and + is still stripped)
542
540
543 '%cpaste -r' re-executes the block previously entered by cpaste.
541 '%cpaste -r' re-executes the block previously entered by cpaste.
544
542
545 Do not be alarmed by garbled output on Windows (it's a readline bug).
543 Do not be alarmed by garbled output on Windows (it's a readline bug).
546 Just press enter and type -- (and press enter again) and the block
544 Just press enter and type -- (and press enter again) and the block
547 will be what was just pasted.
545 will be what was just pasted.
548
546
549 IPython statements (magics, shell escapes) are not supported (yet).
547 IPython statements (magics, shell escapes) are not supported (yet).
550
548
551 See also
549 See also
552 --------
550 --------
553 paste: automatically pull code from clipboard.
551 paste: automatically pull code from clipboard.
554
552
555 Examples
553 Examples
556 --------
554 --------
557 ::
555 ::
558
556
559 In [8]: %cpaste
557 In [8]: %cpaste
560 Pasting code; enter '--' alone on the line to stop.
558 Pasting code; enter '--' alone on the line to stop.
561 :>>> a = ["world!", "Hello"]
559 :>>> a = ["world!", "Hello"]
562 :>>> print " ".join(sorted(a))
560 :>>> print " ".join(sorted(a))
563 :--
561 :--
564 Hello world!
562 Hello world!
565 """
563 """
566
564
567 opts,args = self.parse_options(parameter_s,'rs:',mode='string')
565 opts,args = self.parse_options(parameter_s,'rs:',mode='string')
568 par = args.strip()
566 par = args.strip()
569 if opts.has_key('r'):
567 if opts.has_key('r'):
570 self._rerun_pasted()
568 self._rerun_pasted()
571 return
569 return
572
570
573 sentinel = opts.get('s','--')
571 sentinel = opts.get('s','--')
574
572
575 block = self._strip_pasted_lines_for_code(
573 block = self._strip_pasted_lines_for_code(
576 self._get_pasted_lines(sentinel))
574 self._get_pasted_lines(sentinel))
577
575
578 self._execute_block(block, par)
576 self._execute_block(block, par)
579
577
580 def magic_paste(self, parameter_s=''):
578 def magic_paste(self, parameter_s=''):
581 """Paste & execute a pre-formatted code block from clipboard.
579 """Paste & execute a pre-formatted code block from clipboard.
582
580
583 The text is pulled directly from the clipboard without user
581 The text is pulled directly from the clipboard without user
584 intervention and printed back on the screen before execution (unless
582 intervention and printed back on the screen before execution (unless
585 the -q flag is given to force quiet mode).
583 the -q flag is given to force quiet mode).
586
584
587 The block is dedented prior to execution to enable execution of method
585 The block is dedented prior to execution to enable execution of method
588 definitions. '>' and '+' characters at the beginning of a line are
586 definitions. '>' and '+' characters at the beginning of a line are
589 ignored, to allow pasting directly from e-mails, diff files and
587 ignored, to allow pasting directly from e-mails, diff files and
590 doctests (the '...' continuation prompt is also stripped). The
588 doctests (the '...' continuation prompt is also stripped). The
591 executed block is also assigned to variable named 'pasted_block' for
589 executed block is also assigned to variable named 'pasted_block' for
592 later editing with '%edit pasted_block'.
590 later editing with '%edit pasted_block'.
593
591
594 You can also pass a variable name as an argument, e.g. '%paste foo'.
592 You can also pass a variable name as an argument, e.g. '%paste foo'.
595 This assigns the pasted block to variable 'foo' as string, without
593 This assigns the pasted block to variable 'foo' as string, without
596 dedenting or executing it (preceding >>> and + is still stripped)
594 dedenting or executing it (preceding >>> and + is still stripped)
597
595
598 Options
596 Options
599 -------
597 -------
600
598
601 -r: re-executes the block previously entered by cpaste.
599 -r: re-executes the block previously entered by cpaste.
602
600
603 -q: quiet mode: do not echo the pasted text back to the terminal.
601 -q: quiet mode: do not echo the pasted text back to the terminal.
604
602
605 IPython statements (magics, shell escapes) are not supported (yet).
603 IPython statements (magics, shell escapes) are not supported (yet).
606
604
607 See also
605 See also
608 --------
606 --------
609 cpaste: manually paste code into terminal until you mark its end.
607 cpaste: manually paste code into terminal until you mark its end.
610 """
608 """
611 opts,args = self.parse_options(parameter_s,'rq',mode='string')
609 opts,args = self.parse_options(parameter_s,'rq',mode='string')
612 par = args.strip()
610 par = args.strip()
613 if opts.has_key('r'):
611 if opts.has_key('r'):
614 self._rerun_pasted()
612 self._rerun_pasted()
615 return
613 return
616
614
617 text = self.shell.hooks.clipboard_get()
615 text = self.shell.hooks.clipboard_get()
618 block = self._strip_pasted_lines_for_code(text.splitlines())
616 block = self._strip_pasted_lines_for_code(text.splitlines())
619
617
620 # By default, echo back to terminal unless quiet mode is requested
618 # By default, echo back to terminal unless quiet mode is requested
621 if not opts.has_key('q'):
619 if not opts.has_key('q'):
622 write = self.shell.write
620 write = self.shell.write
623 write(self.shell.pycolorize(block))
621 write(self.shell.pycolorize(block))
624 if not block.endswith('\n'):
622 if not block.endswith('\n'):
625 write('\n')
623 write('\n')
626 write("## -- End pasted text --\n")
624 write("## -- End pasted text --\n")
627
625
628 self._execute_block(block, par)
626 self._execute_block(block, par)
629
627
630 if sys.platform == 'win32':
628 if sys.platform == 'win32':
631 def magic_cls(self, s):
629 def magic_cls(self, s):
632 """Clear screen.
630 """Clear screen.
633 """
631 """
634 os.system("cls")
632 os.system("cls")
635
633
636 def showindentationerror(self):
634 def showindentationerror(self):
637 super(TerminalInteractiveShell, self).showindentationerror()
635 super(TerminalInteractiveShell, self).showindentationerror()
638 print("If you want to paste code into IPython, try the %paste magic function.")
636 print("If you want to paste code into IPython, try the %paste magic function.")
639
637
640
638
641 InteractiveShellABC.register(TerminalInteractiveShell)
639 InteractiveShellABC.register(TerminalInteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now