##// END OF EJS Templates
Make enable_gui a staticmethod again
Thomas Kluyver -
Show More
@@ -1,742 +1,743 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-2011 The IPython Development Team
7 # Copyright (C) 2008-2011 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 from __future__ import print_function
16 from __future__ import print_function
17
17
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 import textwrap
22 import textwrap
23
23
24 # We need to use nested to support python 2.6, once we move to >=2.7, we can
24 # We need to use nested to support python 2.6, once we move to >=2.7, we can
25 # use the with keyword's new builtin support for nested managers
25 # use the with keyword's new builtin support for nested managers
26 try:
26 try:
27 from contextlib import nested
27 from contextlib import nested
28 except:
28 except:
29 from IPython.utils.nested_context import nested
29 from IPython.utils.nested_context import nested
30
30
31 from IPython.core.error import TryNext, UsageError
31 from IPython.core.error import TryNext, UsageError
32 from IPython.core.usage import interactive_usage, default_banner
32 from IPython.core.usage import interactive_usage, default_banner
33 from IPython.core.inputsplitter import IPythonInputSplitter
33 from IPython.core.inputsplitter import IPythonInputSplitter
34 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
34 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
35 from IPython.core.magic import Magics, magics_class, line_magic
35 from IPython.core.magic import Magics, magics_class, line_magic
36 from IPython.testing.skipdoctest import skip_doctest
36 from IPython.testing.skipdoctest import skip_doctest
37 from IPython.utils.encoding import get_stream_enc
37 from IPython.utils.encoding import get_stream_enc
38 from IPython.utils import py3compat
38 from IPython.utils import py3compat
39 from IPython.utils.terminal import toggle_set_term_title, set_term_title
39 from IPython.utils.terminal import toggle_set_term_title, set_term_title
40 from IPython.utils.process import abbrev_cwd
40 from IPython.utils.process import abbrev_cwd
41 from IPython.utils.warn import warn, error
41 from IPython.utils.warn import warn, error
42 from IPython.utils.text import num_ini_spaces, SList, strip_email_quotes
42 from IPython.utils.text import num_ini_spaces, SList, strip_email_quotes
43 from IPython.utils.traitlets import Integer, CBool, Unicode
43 from IPython.utils.traitlets import Integer, CBool, Unicode
44
44
45 #-----------------------------------------------------------------------------
45 #-----------------------------------------------------------------------------
46 # Utilities
46 # Utilities
47 #-----------------------------------------------------------------------------
47 #-----------------------------------------------------------------------------
48
48
49 def get_default_editor():
49 def get_default_editor():
50 try:
50 try:
51 ed = os.environ['EDITOR']
51 ed = os.environ['EDITOR']
52 except KeyError:
52 except KeyError:
53 if os.name == 'posix':
53 if os.name == 'posix':
54 ed = 'vi' # the only one guaranteed to be there!
54 ed = 'vi' # the only one guaranteed to be there!
55 else:
55 else:
56 ed = 'notepad' # same in Windows!
56 ed = 'notepad' # same in Windows!
57 return ed
57 return ed
58
58
59
59
60 def get_pasted_lines(sentinel, l_input=py3compat.input):
60 def get_pasted_lines(sentinel, l_input=py3compat.input):
61 """ Yield pasted lines until the user enters the given sentinel value.
61 """ Yield pasted lines until the user enters the given sentinel value.
62 """
62 """
63 print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
63 print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
64 % sentinel)
64 % sentinel)
65 while True:
65 while True:
66 try:
66 try:
67 l = l_input(':')
67 l = l_input(':')
68 if l == sentinel:
68 if l == sentinel:
69 return
69 return
70 else:
70 else:
71 yield l
71 yield l
72 except EOFError:
72 except EOFError:
73 print('<EOF>')
73 print('<EOF>')
74 return
74 return
75
75
76
76
77 #------------------------------------------------------------------------
77 #------------------------------------------------------------------------
78 # Terminal-specific magics
78 # Terminal-specific magics
79 #------------------------------------------------------------------------
79 #------------------------------------------------------------------------
80
80
81 @magics_class
81 @magics_class
82 class TerminalMagics(Magics):
82 class TerminalMagics(Magics):
83 def __init__(self, shell):
83 def __init__(self, shell):
84 super(TerminalMagics, self).__init__(shell)
84 super(TerminalMagics, self).__init__(shell)
85 self.input_splitter = IPythonInputSplitter(input_mode='line')
85 self.input_splitter = IPythonInputSplitter(input_mode='line')
86
86
87 def cleanup_input(self, block):
87 def cleanup_input(self, block):
88 """Apply all possible IPython cleanups to an input block.
88 """Apply all possible IPython cleanups to an input block.
89
89
90 This means:
90 This means:
91
91
92 - remove any global leading whitespace (dedent)
92 - remove any global leading whitespace (dedent)
93 - remove any email quotes ('>') if they are present in *all* lines
93 - remove any email quotes ('>') if they are present in *all* lines
94 - apply all static inputsplitter transforms and break into sub-blocks
94 - apply all static inputsplitter transforms and break into sub-blocks
95 - apply prefilter() to each sub-block that is a single line.
95 - apply prefilter() to each sub-block that is a single line.
96
96
97 Parameters
97 Parameters
98 ----------
98 ----------
99 block : str
99 block : str
100 A possibly multiline input string of code.
100 A possibly multiline input string of code.
101
101
102 Returns
102 Returns
103 -------
103 -------
104 transformed block : str
104 transformed block : str
105 The input, with all transformations above applied.
105 The input, with all transformations above applied.
106 """
106 """
107 # We have to effectively implement client-side the loop that is done by
107 # We have to effectively implement client-side the loop that is done by
108 # the terminal frontend, and furthermore do it on a block that can
108 # the terminal frontend, and furthermore do it on a block that can
109 # possibly contain multiple statments pasted in one go.
109 # possibly contain multiple statments pasted in one go.
110
110
111 # First, run the input through the block splitting code. We should
111 # First, run the input through the block splitting code. We should
112 # eventually make this a self-contained method in the inputsplitter.
112 # eventually make this a self-contained method in the inputsplitter.
113 isp = self.input_splitter
113 isp = self.input_splitter
114 isp.reset()
114 isp.reset()
115 b = textwrap.dedent(block)
115 b = textwrap.dedent(block)
116
116
117 # Remove email quotes first. These must be consistently applied to
117 # Remove email quotes first. These must be consistently applied to
118 # *all* lines to be removed
118 # *all* lines to be removed
119 b = strip_email_quotes(b)
119 b = strip_email_quotes(b)
120
120
121 # Split the input into independent sub-blocks so we can later do
121 # Split the input into independent sub-blocks so we can later do
122 # prefiltering (which must be done *only* to single-line inputs)
122 # prefiltering (which must be done *only* to single-line inputs)
123 blocks = []
123 blocks = []
124 last_block = []
124 last_block = []
125 for line in b.splitlines():
125 for line in b.splitlines():
126 isp.push(line)
126 isp.push(line)
127 last_block.append(line)
127 last_block.append(line)
128 if not isp.push_accepts_more():
128 if not isp.push_accepts_more():
129 blocks.append(isp.source_reset())
129 blocks.append(isp.source_reset())
130 last_block = []
130 last_block = []
131 if last_block:
131 if last_block:
132 blocks.append('\n'.join(last_block))
132 blocks.append('\n'.join(last_block))
133
133
134 # Now, apply prefiltering to any one-line block to match the behavior
134 # Now, apply prefiltering to any one-line block to match the behavior
135 # of the interactive terminal
135 # of the interactive terminal
136 final_blocks = []
136 final_blocks = []
137 for block in blocks:
137 for block in blocks:
138 lines = block.splitlines()
138 lines = block.splitlines()
139 if len(lines) == 1:
139 if len(lines) == 1:
140 final_blocks.append(self.shell.prefilter(lines[0]))
140 final_blocks.append(self.shell.prefilter(lines[0]))
141 else:
141 else:
142 final_blocks.append(block)
142 final_blocks.append(block)
143
143
144 # We now have the final version of the input code as a list of blocks,
144 # We now have the final version of the input code as a list of blocks,
145 # with all inputsplitter transformations applied and single-line blocks
145 # with all inputsplitter transformations applied and single-line blocks
146 # run through prefilter. For further processing, turn into a single
146 # run through prefilter. For further processing, turn into a single
147 # string as the rest of our apis use string inputs.
147 # string as the rest of our apis use string inputs.
148 return '\n'.join(final_blocks)
148 return '\n'.join(final_blocks)
149
149
150 def store_or_execute(self, block, name):
150 def store_or_execute(self, block, name):
151 """ Execute a block, or store it in a variable, per the user's request.
151 """ Execute a block, or store it in a variable, per the user's request.
152 """
152 """
153
153
154 b = self.cleanup_input(block)
154 b = self.cleanup_input(block)
155 if name:
155 if name:
156 # If storing it for further editing
156 # If storing it for further editing
157 self.shell.user_ns[name] = SList(b.splitlines())
157 self.shell.user_ns[name] = SList(b.splitlines())
158 print("Block assigned to '%s'" % name)
158 print("Block assigned to '%s'" % name)
159 else:
159 else:
160 self.shell.user_ns['pasted_block'] = b
160 self.shell.user_ns['pasted_block'] = b
161 self.shell.using_paste_magics = True
161 self.shell.using_paste_magics = True
162 try:
162 try:
163 self.shell.run_cell(b)
163 self.shell.run_cell(b)
164 finally:
164 finally:
165 self.shell.using_paste_magics = False
165 self.shell.using_paste_magics = False
166
166
167 def rerun_pasted(self, name='pasted_block'):
167 def rerun_pasted(self, name='pasted_block'):
168 """ Rerun a previously pasted command.
168 """ Rerun a previously pasted command.
169 """
169 """
170 b = self.shell.user_ns.get(name)
170 b = self.shell.user_ns.get(name)
171
171
172 # Sanity checks
172 # Sanity checks
173 if b is None:
173 if b is None:
174 raise UsageError('No previous pasted block available')
174 raise UsageError('No previous pasted block available')
175 if not isinstance(b, basestring):
175 if not isinstance(b, basestring):
176 raise UsageError(
176 raise UsageError(
177 "Variable 'pasted_block' is not a string, can't execute")
177 "Variable 'pasted_block' is not a string, can't execute")
178
178
179 print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
179 print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
180 self.shell.run_cell(b)
180 self.shell.run_cell(b)
181
181
182 @line_magic
182 @line_magic
183 def autoindent(self, parameter_s = ''):
183 def autoindent(self, parameter_s = ''):
184 """Toggle autoindent on/off (if available)."""
184 """Toggle autoindent on/off (if available)."""
185
185
186 self.shell.set_autoindent()
186 self.shell.set_autoindent()
187 print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
187 print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
188
188
189 @skip_doctest
189 @skip_doctest
190 @line_magic
190 @line_magic
191 def cpaste(self, parameter_s=''):
191 def cpaste(self, parameter_s=''):
192 """Paste & execute a pre-formatted code block from clipboard.
192 """Paste & execute a pre-formatted code block from clipboard.
193
193
194 You must terminate the block with '--' (two minus-signs) or Ctrl-D
194 You must terminate the block with '--' (two minus-signs) or Ctrl-D
195 alone on the line. You can also provide your own sentinel with '%paste
195 alone on the line. You can also provide your own sentinel with '%paste
196 -s %%' ('%%' is the new sentinel for this operation)
196 -s %%' ('%%' is the new sentinel for this operation)
197
197
198 The block is dedented prior to execution to enable execution of method
198 The block is dedented prior to execution to enable execution of method
199 definitions. '>' and '+' characters at the beginning of a line are
199 definitions. '>' and '+' characters at the beginning of a line are
200 ignored, to allow pasting directly from e-mails, diff files and
200 ignored, to allow pasting directly from e-mails, diff files and
201 doctests (the '...' continuation prompt is also stripped). The
201 doctests (the '...' continuation prompt is also stripped). The
202 executed block is also assigned to variable named 'pasted_block' for
202 executed block is also assigned to variable named 'pasted_block' for
203 later editing with '%edit pasted_block'.
203 later editing with '%edit pasted_block'.
204
204
205 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
205 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
206 This assigns the pasted block to variable 'foo' as string, without
206 This assigns the pasted block to variable 'foo' as string, without
207 dedenting or executing it (preceding >>> and + is still stripped)
207 dedenting or executing it (preceding >>> and + is still stripped)
208
208
209 '%cpaste -r' re-executes the block previously entered by cpaste.
209 '%cpaste -r' re-executes the block previously entered by cpaste.
210
210
211 Do not be alarmed by garbled output on Windows (it's a readline bug).
211 Do not be alarmed by garbled output on Windows (it's a readline bug).
212 Just press enter and type -- (and press enter again) and the block
212 Just press enter and type -- (and press enter again) and the block
213 will be what was just pasted.
213 will be what was just pasted.
214
214
215 IPython statements (magics, shell escapes) are not supported (yet).
215 IPython statements (magics, shell escapes) are not supported (yet).
216
216
217 See also
217 See also
218 --------
218 --------
219 paste: automatically pull code from clipboard.
219 paste: automatically pull code from clipboard.
220
220
221 Examples
221 Examples
222 --------
222 --------
223 ::
223 ::
224
224
225 In [8]: %cpaste
225 In [8]: %cpaste
226 Pasting code; enter '--' alone on the line to stop.
226 Pasting code; enter '--' alone on the line to stop.
227 :>>> a = ["world!", "Hello"]
227 :>>> a = ["world!", "Hello"]
228 :>>> print " ".join(sorted(a))
228 :>>> print " ".join(sorted(a))
229 :--
229 :--
230 Hello world!
230 Hello world!
231 """
231 """
232 opts, name = self.parse_options(parameter_s, 'rs:', mode='string')
232 opts, name = self.parse_options(parameter_s, 'rs:', mode='string')
233 if 'r' in opts:
233 if 'r' in opts:
234 self.rerun_pasted()
234 self.rerun_pasted()
235 return
235 return
236
236
237 sentinel = opts.get('s', '--')
237 sentinel = opts.get('s', '--')
238 block = '\n'.join(get_pasted_lines(sentinel))
238 block = '\n'.join(get_pasted_lines(sentinel))
239 self.store_or_execute(block, name)
239 self.store_or_execute(block, name)
240
240
241 @line_magic
241 @line_magic
242 def paste(self, parameter_s=''):
242 def paste(self, parameter_s=''):
243 """Paste & execute a pre-formatted code block from clipboard.
243 """Paste & execute a pre-formatted code block from clipboard.
244
244
245 The text is pulled directly from the clipboard without user
245 The text is pulled directly from the clipboard without user
246 intervention and printed back on the screen before execution (unless
246 intervention and printed back on the screen before execution (unless
247 the -q flag is given to force quiet mode).
247 the -q flag is given to force quiet mode).
248
248
249 The block is dedented prior to execution to enable execution of method
249 The block is dedented prior to execution to enable execution of method
250 definitions. '>' and '+' characters at the beginning of a line are
250 definitions. '>' and '+' characters at the beginning of a line are
251 ignored, to allow pasting directly from e-mails, diff files and
251 ignored, to allow pasting directly from e-mails, diff files and
252 doctests (the '...' continuation prompt is also stripped). The
252 doctests (the '...' continuation prompt is also stripped). The
253 executed block is also assigned to variable named 'pasted_block' for
253 executed block is also assigned to variable named 'pasted_block' for
254 later editing with '%edit pasted_block'.
254 later editing with '%edit pasted_block'.
255
255
256 You can also pass a variable name as an argument, e.g. '%paste foo'.
256 You can also pass a variable name as an argument, e.g. '%paste foo'.
257 This assigns the pasted block to variable 'foo' as string, without
257 This assigns the pasted block to variable 'foo' as string, without
258 executing it (preceding >>> and + is still stripped).
258 executing it (preceding >>> and + is still stripped).
259
259
260 Options
260 Options
261 -------
261 -------
262
262
263 -r: re-executes the block previously entered by cpaste.
263 -r: re-executes the block previously entered by cpaste.
264
264
265 -q: quiet mode: do not echo the pasted text back to the terminal.
265 -q: quiet mode: do not echo the pasted text back to the terminal.
266
266
267 IPython statements (magics, shell escapes) are not supported (yet).
267 IPython statements (magics, shell escapes) are not supported (yet).
268
268
269 See also
269 See also
270 --------
270 --------
271 cpaste: manually paste code into terminal until you mark its end.
271 cpaste: manually paste code into terminal until you mark its end.
272 """
272 """
273 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
273 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
274 if 'r' in opts:
274 if 'r' in opts:
275 self.rerun_pasted()
275 self.rerun_pasted()
276 return
276 return
277 try:
277 try:
278 block = self.shell.hooks.clipboard_get()
278 block = self.shell.hooks.clipboard_get()
279 except TryNext as clipboard_exc:
279 except TryNext as clipboard_exc:
280 message = getattr(clipboard_exc, 'args')
280 message = getattr(clipboard_exc, 'args')
281 if message:
281 if message:
282 error(message[0])
282 error(message[0])
283 else:
283 else:
284 error('Could not get text from the clipboard.')
284 error('Could not get text from the clipboard.')
285 return
285 return
286
286
287 # By default, echo back to terminal unless quiet mode is requested
287 # By default, echo back to terminal unless quiet mode is requested
288 if 'q' not in opts:
288 if 'q' not in opts:
289 write = self.shell.write
289 write = self.shell.write
290 write(self.shell.pycolorize(block))
290 write(self.shell.pycolorize(block))
291 if not block.endswith('\n'):
291 if not block.endswith('\n'):
292 write('\n')
292 write('\n')
293 write("## -- End pasted text --\n")
293 write("## -- End pasted text --\n")
294
294
295 self.store_or_execute(block, name)
295 self.store_or_execute(block, name)
296
296
297 # Class-level: add a '%cls' magic only on Windows
297 # Class-level: add a '%cls' magic only on Windows
298 if sys.platform == 'win32':
298 if sys.platform == 'win32':
299 @line_magic
299 @line_magic
300 def cls(self, s):
300 def cls(self, s):
301 """Clear screen.
301 """Clear screen.
302 """
302 """
303 os.system("cls")
303 os.system("cls")
304
304
305 #-----------------------------------------------------------------------------
305 #-----------------------------------------------------------------------------
306 # Main class
306 # Main class
307 #-----------------------------------------------------------------------------
307 #-----------------------------------------------------------------------------
308
308
309 class TerminalInteractiveShell(InteractiveShell):
309 class TerminalInteractiveShell(InteractiveShell):
310
310
311 autoedit_syntax = CBool(False, config=True,
311 autoedit_syntax = CBool(False, config=True,
312 help="auto editing of files with syntax errors.")
312 help="auto editing of files with syntax errors.")
313 banner = Unicode('')
313 banner = Unicode('')
314 banner1 = Unicode(default_banner, config=True,
314 banner1 = Unicode(default_banner, config=True,
315 help="""The part of the banner to be printed before the profile"""
315 help="""The part of the banner to be printed before the profile"""
316 )
316 )
317 banner2 = Unicode('', config=True,
317 banner2 = Unicode('', config=True,
318 help="""The part of the banner to be printed after the profile"""
318 help="""The part of the banner to be printed after the profile"""
319 )
319 )
320 confirm_exit = CBool(True, config=True,
320 confirm_exit = CBool(True, config=True,
321 help="""
321 help="""
322 Set to confirm when you try to exit IPython with an EOF (Control-D
322 Set to confirm when you try to exit IPython with an EOF (Control-D
323 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
323 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
324 you can force a direct exit without any confirmation.""",
324 you can force a direct exit without any confirmation.""",
325 )
325 )
326 # This display_banner only controls whether or not self.show_banner()
326 # This display_banner only controls whether or not self.show_banner()
327 # is called when mainloop/interact are called. The default is False
327 # is called when mainloop/interact are called. The default is False
328 # because for the terminal based application, the banner behavior
328 # because for the terminal based application, the banner behavior
329 # is controlled by Global.display_banner, which IPythonApp looks at
329 # is controlled by Global.display_banner, which IPythonApp looks at
330 # to determine if *it* should call show_banner() by hand or not.
330 # to determine if *it* should call show_banner() by hand or not.
331 display_banner = CBool(False) # This isn't configurable!
331 display_banner = CBool(False) # This isn't configurable!
332 embedded = CBool(False)
332 embedded = CBool(False)
333 embedded_active = CBool(False)
333 embedded_active = CBool(False)
334 editor = Unicode(get_default_editor(), config=True,
334 editor = Unicode(get_default_editor(), config=True,
335 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
335 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
336 )
336 )
337 pager = Unicode('less', config=True,
337 pager = Unicode('less', config=True,
338 help="The shell program to be used for paging.")
338 help="The shell program to be used for paging.")
339
339
340 screen_length = Integer(0, config=True,
340 screen_length = Integer(0, config=True,
341 help=
341 help=
342 """Number of lines of your screen, used to control printing of very
342 """Number of lines of your screen, used to control printing of very
343 long strings. Strings longer than this number of lines will be sent
343 long strings. Strings longer than this number of lines will be sent
344 through a pager instead of directly printed. The default value for
344 through a pager instead of directly printed. The default value for
345 this is 0, which means IPython will auto-detect your screen size every
345 this is 0, which means IPython will auto-detect your screen size every
346 time it needs to print certain potentially long strings (this doesn't
346 time it needs to print certain potentially long strings (this doesn't
347 change the behavior of the 'print' keyword, it's only triggered
347 change the behavior of the 'print' keyword, it's only triggered
348 internally). If for some reason this isn't working well (it needs
348 internally). If for some reason this isn't working well (it needs
349 curses support), specify it yourself. Otherwise don't change the
349 curses support), specify it yourself. Otherwise don't change the
350 default.""",
350 default.""",
351 )
351 )
352 term_title = CBool(False, config=True,
352 term_title = CBool(False, config=True,
353 help="Enable auto setting the terminal title."
353 help="Enable auto setting the terminal title."
354 )
354 )
355
355
356 # This `using_paste_magics` is used to detect whether the code is being
356 # This `using_paste_magics` is used to detect whether the code is being
357 # executed via paste magics functions
357 # executed via paste magics functions
358 using_paste_magics = CBool(False)
358 using_paste_magics = CBool(False)
359
359
360 # In the terminal, GUI control is done via PyOS_InputHook
360 # In the terminal, GUI control is done via PyOS_InputHook
361 @staticmethod
361 def enable_gui(gui=None, app=None):
362 def enable_gui(gui=None, app=None):
362 """Switch amongst GUI input hooks by name.
363 """Switch amongst GUI input hooks by name.
363 """
364 """
364 # Deferred import
365 # Deferred import
365 from IPython.lib.inputhook import enable_gui as real_enable_gui
366 from IPython.lib.inputhook import enable_gui as real_enable_gui
366 return real_enable_gui(gui, app)
367 return real_enable_gui(gui, app)
367
368
368 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
369 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
369 user_ns=None, user_module=None, custom_exceptions=((),None),
370 user_ns=None, user_module=None, custom_exceptions=((),None),
370 usage=None, banner1=None, banner2=None, display_banner=None):
371 usage=None, banner1=None, banner2=None, display_banner=None):
371
372
372 super(TerminalInteractiveShell, self).__init__(
373 super(TerminalInteractiveShell, self).__init__(
373 config=config, ipython_dir=ipython_dir, profile_dir=profile_dir, user_ns=user_ns,
374 config=config, ipython_dir=ipython_dir, profile_dir=profile_dir, user_ns=user_ns,
374 user_module=user_module, custom_exceptions=custom_exceptions
375 user_module=user_module, custom_exceptions=custom_exceptions
375 )
376 )
376 # use os.system instead of utils.process.system by default,
377 # use os.system instead of utils.process.system by default,
377 # because piped system doesn't make sense in the Terminal:
378 # because piped system doesn't make sense in the Terminal:
378 self.system = self.system_raw
379 self.system = self.system_raw
379
380
380 self.init_term_title()
381 self.init_term_title()
381 self.init_usage(usage)
382 self.init_usage(usage)
382 self.init_banner(banner1, banner2, display_banner)
383 self.init_banner(banner1, banner2, display_banner)
383
384
384 #-------------------------------------------------------------------------
385 #-------------------------------------------------------------------------
385 # Things related to the terminal
386 # Things related to the terminal
386 #-------------------------------------------------------------------------
387 #-------------------------------------------------------------------------
387
388
388 @property
389 @property
389 def usable_screen_length(self):
390 def usable_screen_length(self):
390 if self.screen_length == 0:
391 if self.screen_length == 0:
391 return 0
392 return 0
392 else:
393 else:
393 num_lines_bot = self.separate_in.count('\n')+1
394 num_lines_bot = self.separate_in.count('\n')+1
394 return self.screen_length - num_lines_bot
395 return self.screen_length - num_lines_bot
395
396
396 def init_term_title(self):
397 def init_term_title(self):
397 # Enable or disable the terminal title.
398 # Enable or disable the terminal title.
398 if self.term_title:
399 if self.term_title:
399 toggle_set_term_title(True)
400 toggle_set_term_title(True)
400 set_term_title('IPython: ' + abbrev_cwd())
401 set_term_title('IPython: ' + abbrev_cwd())
401 else:
402 else:
402 toggle_set_term_title(False)
403 toggle_set_term_title(False)
403
404
404 #-------------------------------------------------------------------------
405 #-------------------------------------------------------------------------
405 # Things related to aliases
406 # Things related to aliases
406 #-------------------------------------------------------------------------
407 #-------------------------------------------------------------------------
407
408
408 def init_alias(self):
409 def init_alias(self):
409 # The parent class defines aliases that can be safely used with any
410 # The parent class defines aliases that can be safely used with any
410 # frontend.
411 # frontend.
411 super(TerminalInteractiveShell, self).init_alias()
412 super(TerminalInteractiveShell, self).init_alias()
412
413
413 # Now define aliases that only make sense on the terminal, because they
414 # Now define aliases that only make sense on the terminal, because they
414 # need direct access to the console in a way that we can't emulate in
415 # need direct access to the console in a way that we can't emulate in
415 # GUI or web frontend
416 # GUI or web frontend
416 if os.name == 'posix':
417 if os.name == 'posix':
417 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
418 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
418 ('man', 'man')]
419 ('man', 'man')]
419 elif os.name == 'nt':
420 elif os.name == 'nt':
420 aliases = [('cls', 'cls')]
421 aliases = [('cls', 'cls')]
421
422
422
423
423 for name, cmd in aliases:
424 for name, cmd in aliases:
424 self.alias_manager.define_alias(name, cmd)
425 self.alias_manager.define_alias(name, cmd)
425
426
426 #-------------------------------------------------------------------------
427 #-------------------------------------------------------------------------
427 # Things related to the banner and usage
428 # Things related to the banner and usage
428 #-------------------------------------------------------------------------
429 #-------------------------------------------------------------------------
429
430
430 def _banner1_changed(self):
431 def _banner1_changed(self):
431 self.compute_banner()
432 self.compute_banner()
432
433
433 def _banner2_changed(self):
434 def _banner2_changed(self):
434 self.compute_banner()
435 self.compute_banner()
435
436
436 def _term_title_changed(self, name, new_value):
437 def _term_title_changed(self, name, new_value):
437 self.init_term_title()
438 self.init_term_title()
438
439
439 def init_banner(self, banner1, banner2, display_banner):
440 def init_banner(self, banner1, banner2, display_banner):
440 if banner1 is not None:
441 if banner1 is not None:
441 self.banner1 = banner1
442 self.banner1 = banner1
442 if banner2 is not None:
443 if banner2 is not None:
443 self.banner2 = banner2
444 self.banner2 = banner2
444 if display_banner is not None:
445 if display_banner is not None:
445 self.display_banner = display_banner
446 self.display_banner = display_banner
446 self.compute_banner()
447 self.compute_banner()
447
448
448 def show_banner(self, banner=None):
449 def show_banner(self, banner=None):
449 if banner is None:
450 if banner is None:
450 banner = self.banner
451 banner = self.banner
451 self.write(banner)
452 self.write(banner)
452
453
453 def compute_banner(self):
454 def compute_banner(self):
454 self.banner = self.banner1
455 self.banner = self.banner1
455 if self.profile and self.profile != 'default':
456 if self.profile and self.profile != 'default':
456 self.banner += '\nIPython profile: %s\n' % self.profile
457 self.banner += '\nIPython profile: %s\n' % self.profile
457 if self.banner2:
458 if self.banner2:
458 self.banner += '\n' + self.banner2
459 self.banner += '\n' + self.banner2
459
460
460 def init_usage(self, usage=None):
461 def init_usage(self, usage=None):
461 if usage is None:
462 if usage is None:
462 self.usage = interactive_usage
463 self.usage = interactive_usage
463 else:
464 else:
464 self.usage = usage
465 self.usage = usage
465
466
466 #-------------------------------------------------------------------------
467 #-------------------------------------------------------------------------
467 # Mainloop and code execution logic
468 # Mainloop and code execution logic
468 #-------------------------------------------------------------------------
469 #-------------------------------------------------------------------------
469
470
470 def mainloop(self, display_banner=None):
471 def mainloop(self, display_banner=None):
471 """Start the mainloop.
472 """Start the mainloop.
472
473
473 If an optional banner argument is given, it will override the
474 If an optional banner argument is given, it will override the
474 internally created default banner.
475 internally created default banner.
475 """
476 """
476
477
477 with nested(self.builtin_trap, self.display_trap):
478 with nested(self.builtin_trap, self.display_trap):
478
479
479 while 1:
480 while 1:
480 try:
481 try:
481 self.interact(display_banner=display_banner)
482 self.interact(display_banner=display_banner)
482 #self.interact_with_readline()
483 #self.interact_with_readline()
483 # XXX for testing of a readline-decoupled repl loop, call
484 # XXX for testing of a readline-decoupled repl loop, call
484 # interact_with_readline above
485 # interact_with_readline above
485 break
486 break
486 except KeyboardInterrupt:
487 except KeyboardInterrupt:
487 # this should not be necessary, but KeyboardInterrupt
488 # this should not be necessary, but KeyboardInterrupt
488 # handling seems rather unpredictable...
489 # handling seems rather unpredictable...
489 self.write("\nKeyboardInterrupt in interact()\n")
490 self.write("\nKeyboardInterrupt in interact()\n")
490
491
491 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
492 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
492 """Store multiple lines as a single entry in history"""
493 """Store multiple lines as a single entry in history"""
493
494
494 # do nothing without readline or disabled multiline
495 # do nothing without readline or disabled multiline
495 if not self.has_readline or not self.multiline_history:
496 if not self.has_readline or not self.multiline_history:
496 return hlen_before_cell
497 return hlen_before_cell
497
498
498 # windows rl has no remove_history_item
499 # windows rl has no remove_history_item
499 if not hasattr(self.readline, "remove_history_item"):
500 if not hasattr(self.readline, "remove_history_item"):
500 return hlen_before_cell
501 return hlen_before_cell
501
502
502 # skip empty cells
503 # skip empty cells
503 if not source_raw.rstrip():
504 if not source_raw.rstrip():
504 return hlen_before_cell
505 return hlen_before_cell
505
506
506 # nothing changed do nothing, e.g. when rl removes consecutive dups
507 # nothing changed do nothing, e.g. when rl removes consecutive dups
507 hlen = self.readline.get_current_history_length()
508 hlen = self.readline.get_current_history_length()
508 if hlen == hlen_before_cell:
509 if hlen == hlen_before_cell:
509 return hlen_before_cell
510 return hlen_before_cell
510
511
511 for i in range(hlen - hlen_before_cell):
512 for i in range(hlen - hlen_before_cell):
512 self.readline.remove_history_item(hlen - i - 1)
513 self.readline.remove_history_item(hlen - i - 1)
513 stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
514 stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
514 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
515 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
515 stdin_encoding))
516 stdin_encoding))
516 return self.readline.get_current_history_length()
517 return self.readline.get_current_history_length()
517
518
518 def interact(self, display_banner=None):
519 def interact(self, display_banner=None):
519 """Closely emulate the interactive Python console."""
520 """Closely emulate the interactive Python console."""
520
521
521 # batch run -> do not interact
522 # batch run -> do not interact
522 if self.exit_now:
523 if self.exit_now:
523 return
524 return
524
525
525 if display_banner is None:
526 if display_banner is None:
526 display_banner = self.display_banner
527 display_banner = self.display_banner
527
528
528 if isinstance(display_banner, basestring):
529 if isinstance(display_banner, basestring):
529 self.show_banner(display_banner)
530 self.show_banner(display_banner)
530 elif display_banner:
531 elif display_banner:
531 self.show_banner()
532 self.show_banner()
532
533
533 more = False
534 more = False
534
535
535 if self.has_readline:
536 if self.has_readline:
536 self.readline_startup_hook(self.pre_readline)
537 self.readline_startup_hook(self.pre_readline)
537 hlen_b4_cell = self.readline.get_current_history_length()
538 hlen_b4_cell = self.readline.get_current_history_length()
538 else:
539 else:
539 hlen_b4_cell = 0
540 hlen_b4_cell = 0
540 # exit_now is set by a call to %Exit or %Quit, through the
541 # exit_now is set by a call to %Exit or %Quit, through the
541 # ask_exit callback.
542 # ask_exit callback.
542
543
543 while not self.exit_now:
544 while not self.exit_now:
544 self.hooks.pre_prompt_hook()
545 self.hooks.pre_prompt_hook()
545 if more:
546 if more:
546 try:
547 try:
547 prompt = self.prompt_manager.render('in2')
548 prompt = self.prompt_manager.render('in2')
548 except:
549 except:
549 self.showtraceback()
550 self.showtraceback()
550 if self.autoindent:
551 if self.autoindent:
551 self.rl_do_indent = True
552 self.rl_do_indent = True
552
553
553 else:
554 else:
554 try:
555 try:
555 prompt = self.separate_in + self.prompt_manager.render('in')
556 prompt = self.separate_in + self.prompt_manager.render('in')
556 except:
557 except:
557 self.showtraceback()
558 self.showtraceback()
558 try:
559 try:
559 line = self.raw_input(prompt)
560 line = self.raw_input(prompt)
560 if self.exit_now:
561 if self.exit_now:
561 # quick exit on sys.std[in|out] close
562 # quick exit on sys.std[in|out] close
562 break
563 break
563 if self.autoindent:
564 if self.autoindent:
564 self.rl_do_indent = False
565 self.rl_do_indent = False
565
566
566 except KeyboardInterrupt:
567 except KeyboardInterrupt:
567 #double-guard against keyboardinterrupts during kbdint handling
568 #double-guard against keyboardinterrupts during kbdint handling
568 try:
569 try:
569 self.write('\nKeyboardInterrupt\n')
570 self.write('\nKeyboardInterrupt\n')
570 source_raw = self.input_splitter.source_raw_reset()[1]
571 source_raw = self.input_splitter.source_raw_reset()[1]
571 hlen_b4_cell = \
572 hlen_b4_cell = \
572 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
573 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
573 more = False
574 more = False
574 except KeyboardInterrupt:
575 except KeyboardInterrupt:
575 pass
576 pass
576 except EOFError:
577 except EOFError:
577 if self.autoindent:
578 if self.autoindent:
578 self.rl_do_indent = False
579 self.rl_do_indent = False
579 if self.has_readline:
580 if self.has_readline:
580 self.readline_startup_hook(None)
581 self.readline_startup_hook(None)
581 self.write('\n')
582 self.write('\n')
582 self.exit()
583 self.exit()
583 except bdb.BdbQuit:
584 except bdb.BdbQuit:
584 warn('The Python debugger has exited with a BdbQuit exception.\n'
585 warn('The Python debugger has exited with a BdbQuit exception.\n'
585 'Because of how pdb handles the stack, it is impossible\n'
586 'Because of how pdb handles the stack, it is impossible\n'
586 'for IPython to properly format this particular exception.\n'
587 'for IPython to properly format this particular exception.\n'
587 'IPython will resume normal operation.')
588 'IPython will resume normal operation.')
588 except:
589 except:
589 # exceptions here are VERY RARE, but they can be triggered
590 # exceptions here are VERY RARE, but they can be triggered
590 # asynchronously by signal handlers, for example.
591 # asynchronously by signal handlers, for example.
591 self.showtraceback()
592 self.showtraceback()
592 else:
593 else:
593 self.input_splitter.push(line)
594 self.input_splitter.push(line)
594 more = self.input_splitter.push_accepts_more()
595 more = self.input_splitter.push_accepts_more()
595 if (self.SyntaxTB.last_syntax_error and
596 if (self.SyntaxTB.last_syntax_error and
596 self.autoedit_syntax):
597 self.autoedit_syntax):
597 self.edit_syntax_error()
598 self.edit_syntax_error()
598 if not more:
599 if not more:
599 source_raw = self.input_splitter.source_raw_reset()[1]
600 source_raw = self.input_splitter.source_raw_reset()[1]
600 self.run_cell(source_raw, store_history=True)
601 self.run_cell(source_raw, store_history=True)
601 hlen_b4_cell = \
602 hlen_b4_cell = \
602 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
603 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
603
604
604 # Turn off the exit flag, so the mainloop can be restarted if desired
605 # Turn off the exit flag, so the mainloop can be restarted if desired
605 self.exit_now = False
606 self.exit_now = False
606
607
607 def raw_input(self, prompt=''):
608 def raw_input(self, prompt=''):
608 """Write a prompt and read a line.
609 """Write a prompt and read a line.
609
610
610 The returned line does not include the trailing newline.
611 The returned line does not include the trailing newline.
611 When the user enters the EOF key sequence, EOFError is raised.
612 When the user enters the EOF key sequence, EOFError is raised.
612
613
613 Optional inputs:
614 Optional inputs:
614
615
615 - prompt(''): a string to be printed to prompt the user.
616 - prompt(''): a string to be printed to prompt the user.
616
617
617 - continue_prompt(False): whether this line is the first one or a
618 - continue_prompt(False): whether this line is the first one or a
618 continuation in a sequence of inputs.
619 continuation in a sequence of inputs.
619 """
620 """
620 # Code run by the user may have modified the readline completer state.
621 # Code run by the user may have modified the readline completer state.
621 # We must ensure that our completer is back in place.
622 # We must ensure that our completer is back in place.
622
623
623 if self.has_readline:
624 if self.has_readline:
624 self.set_readline_completer()
625 self.set_readline_completer()
625
626
626 # raw_input expects str, but we pass it unicode sometimes
627 # raw_input expects str, but we pass it unicode sometimes
627 prompt = py3compat.cast_bytes_py2(prompt)
628 prompt = py3compat.cast_bytes_py2(prompt)
628
629
629 try:
630 try:
630 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
631 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
631 except ValueError:
632 except ValueError:
632 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
633 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
633 " or sys.stdout.close()!\nExiting IPython!\n")
634 " or sys.stdout.close()!\nExiting IPython!\n")
634 self.ask_exit()
635 self.ask_exit()
635 return ""
636 return ""
636
637
637 # Try to be reasonably smart about not re-indenting pasted input more
638 # Try to be reasonably smart about not re-indenting pasted input more
638 # than necessary. We do this by trimming out the auto-indent initial
639 # than necessary. We do this by trimming out the auto-indent initial
639 # spaces, if the user's actual input started itself with whitespace.
640 # spaces, if the user's actual input started itself with whitespace.
640 if self.autoindent:
641 if self.autoindent:
641 if num_ini_spaces(line) > self.indent_current_nsp:
642 if num_ini_spaces(line) > self.indent_current_nsp:
642 line = line[self.indent_current_nsp:]
643 line = line[self.indent_current_nsp:]
643 self.indent_current_nsp = 0
644 self.indent_current_nsp = 0
644
645
645 return line
646 return line
646
647
647 #-------------------------------------------------------------------------
648 #-------------------------------------------------------------------------
648 # Methods to support auto-editing of SyntaxErrors.
649 # Methods to support auto-editing of SyntaxErrors.
649 #-------------------------------------------------------------------------
650 #-------------------------------------------------------------------------
650
651
651 def edit_syntax_error(self):
652 def edit_syntax_error(self):
652 """The bottom half of the syntax error handler called in the main loop.
653 """The bottom half of the syntax error handler called in the main loop.
653
654
654 Loop until syntax error is fixed or user cancels.
655 Loop until syntax error is fixed or user cancels.
655 """
656 """
656
657
657 while self.SyntaxTB.last_syntax_error:
658 while self.SyntaxTB.last_syntax_error:
658 # copy and clear last_syntax_error
659 # copy and clear last_syntax_error
659 err = self.SyntaxTB.clear_err_state()
660 err = self.SyntaxTB.clear_err_state()
660 if not self._should_recompile(err):
661 if not self._should_recompile(err):
661 return
662 return
662 try:
663 try:
663 # may set last_syntax_error again if a SyntaxError is raised
664 # may set last_syntax_error again if a SyntaxError is raised
664 self.safe_execfile(err.filename,self.user_ns)
665 self.safe_execfile(err.filename,self.user_ns)
665 except:
666 except:
666 self.showtraceback()
667 self.showtraceback()
667 else:
668 else:
668 try:
669 try:
669 f = open(err.filename)
670 f = open(err.filename)
670 try:
671 try:
671 # This should be inside a display_trap block and I
672 # This should be inside a display_trap block and I
672 # think it is.
673 # think it is.
673 sys.displayhook(f.read())
674 sys.displayhook(f.read())
674 finally:
675 finally:
675 f.close()
676 f.close()
676 except:
677 except:
677 self.showtraceback()
678 self.showtraceback()
678
679
679 def _should_recompile(self,e):
680 def _should_recompile(self,e):
680 """Utility routine for edit_syntax_error"""
681 """Utility routine for edit_syntax_error"""
681
682
682 if e.filename in ('<ipython console>','<input>','<string>',
683 if e.filename in ('<ipython console>','<input>','<string>',
683 '<console>','<BackgroundJob compilation>',
684 '<console>','<BackgroundJob compilation>',
684 None):
685 None):
685
686
686 return False
687 return False
687 try:
688 try:
688 if (self.autoedit_syntax and
689 if (self.autoedit_syntax and
689 not self.ask_yes_no('Return to editor to correct syntax error? '
690 not self.ask_yes_no('Return to editor to correct syntax error? '
690 '[Y/n] ','y')):
691 '[Y/n] ','y')):
691 return False
692 return False
692 except EOFError:
693 except EOFError:
693 return False
694 return False
694
695
695 def int0(x):
696 def int0(x):
696 try:
697 try:
697 return int(x)
698 return int(x)
698 except TypeError:
699 except TypeError:
699 return 0
700 return 0
700 # always pass integer line and offset values to editor hook
701 # always pass integer line and offset values to editor hook
701 try:
702 try:
702 self.hooks.fix_error_editor(e.filename,
703 self.hooks.fix_error_editor(e.filename,
703 int0(e.lineno),int0(e.offset),e.msg)
704 int0(e.lineno),int0(e.offset),e.msg)
704 except TryNext:
705 except TryNext:
705 warn('Could not open editor')
706 warn('Could not open editor')
706 return False
707 return False
707 return True
708 return True
708
709
709 #-------------------------------------------------------------------------
710 #-------------------------------------------------------------------------
710 # Things related to exiting
711 # Things related to exiting
711 #-------------------------------------------------------------------------
712 #-------------------------------------------------------------------------
712
713
713 def ask_exit(self):
714 def ask_exit(self):
714 """ Ask the shell to exit. Can be overiden and used as a callback. """
715 """ Ask the shell to exit. Can be overiden and used as a callback. """
715 self.exit_now = True
716 self.exit_now = True
716
717
717 def exit(self):
718 def exit(self):
718 """Handle interactive exit.
719 """Handle interactive exit.
719
720
720 This method calls the ask_exit callback."""
721 This method calls the ask_exit callback."""
721 if self.confirm_exit:
722 if self.confirm_exit:
722 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
723 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
723 self.ask_exit()
724 self.ask_exit()
724 else:
725 else:
725 self.ask_exit()
726 self.ask_exit()
726
727
727 #-------------------------------------------------------------------------
728 #-------------------------------------------------------------------------
728 # Things related to magics
729 # Things related to magics
729 #-------------------------------------------------------------------------
730 #-------------------------------------------------------------------------
730
731
731 def init_magics(self):
732 def init_magics(self):
732 super(TerminalInteractiveShell, self).init_magics()
733 super(TerminalInteractiveShell, self).init_magics()
733 self.register_magics(TerminalMagics)
734 self.register_magics(TerminalMagics)
734
735
735 def showindentationerror(self):
736 def showindentationerror(self):
736 super(TerminalInteractiveShell, self).showindentationerror()
737 super(TerminalInteractiveShell, self).showindentationerror()
737 if not self.using_paste_magics:
738 if not self.using_paste_magics:
738 print("If you want to paste code into IPython, try the "
739 print("If you want to paste code into IPython, try the "
739 "%paste and %cpaste magic functions.")
740 "%paste and %cpaste magic functions.")
740
741
741
742
742 InteractiveShellABC.register(TerminalInteractiveShell)
743 InteractiveShellABC.register(TerminalInteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now