interactiveshell.py
692 lines
| 25.1 KiB
| text/x-python
|
PythonLexer
|
r22557 | """IPython terminal interface using prompt_toolkit""" | ||
|
r21846 | |||
|
r25276 | import asyncio | ||
|
r22549 | import os | ||
import sys | ||||
|
r22742 | import warnings | ||
|
r22092 | from warnings import warn | ||
|
r2761 | |||
|
r22549 | from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC | ||
|
r22742 | from IPython.utils import io | ||
|
r24010 | from IPython.utils.py3compat import input | ||
|
r25194 | from IPython.utils.terminal import toggle_set_term_title, set_term_title, restore_term_title | ||
|
r22549 | from IPython.utils.process import abbrev_cwd | ||
|
r23580 | from traitlets import ( | ||
|
r26113 | Bool, | ||
Unicode, | ||||
Dict, | ||||
Integer, | ||||
observe, | ||||
Instance, | ||||
Type, | ||||
default, | ||||
Enum, | ||||
Union, | ||||
Any, | ||||
validate, | ||||
Float, | ||||
|
r23580 | ) | ||
|
r22549 | |||
|
r26102 | from prompt_toolkit.auto_suggest import AutoSuggestFromHistory | ||
|
r22642 | from prompt_toolkit.enums import DEFAULT_BUFFER, EditingMode | ||
from prompt_toolkit.filters import (HasFocus, Condition, IsDone) | ||||
|
r24376 | from prompt_toolkit.formatted_text import PygmentsTokens | ||
|
r22549 | from prompt_toolkit.history import InMemoryHistory | ||
from prompt_toolkit.layout.processors import ConditionalProcessor, HighlightMatchingBracketProcessor | ||||
|
r24377 | from prompt_toolkit.output import ColorDepth | ||
|
r24376 | from prompt_toolkit.patch_stdout import patch_stdout | ||
|
r24379 | from prompt_toolkit.shortcuts import PromptSession, CompleteStyle, print_formatted_text | ||
|
r24376 | from prompt_toolkit.styles import DynamicStyle, merge_styles | ||
from prompt_toolkit.styles.pygments import style_from_pygments_cls, style_from_pygments_dict | ||||
|
r25268 | from prompt_toolkit import __version__ as ptk_version | ||
|
r22549 | |||
|
r23995 | from pygments.styles import get_style_by_name | ||
|
r22766 | from pygments.style import Style | ||
|
r22549 | from pygments.token import Token | ||
from .debugger import TerminalPdb, Pdb | ||||
from .magics import TerminalMagics | ||||
|
r22913 | from .pt_inputhooks import get_inputhook_name_and_func | ||
|
r22549 | from .prompts import Prompts, ClassicPrompts, RichPromptDisplayHook | ||
from .ptutils import IPythonPTCompleter, IPythonPTLexer | ||||
|
r24376 | from .shortcuts import create_ipython_shortcuts | ||
|
r22549 | |||
|
r25268 | PTK3 = ptk_version.startswith('3.') | ||
|
r22562 | |||
|
r22549 | |||
|
r22578 | class _NoStyle(Style): pass | ||
_style_overrides_light_bg = { | ||||
|
r25894 | Token.Prompt: '#ansibrightblue', | ||
Token.PromptNum: '#ansiblue bold', | ||||
Token.OutPrompt: '#ansibrightred', | ||||
Token.OutPromptNum: '#ansired bold', | ||||
|
r22578 | } | ||
_style_overrides_linux = { | ||||
|
r25894 | Token.Prompt: '#ansibrightgreen', | ||
Token.PromptNum: '#ansigreen bold', | ||||
Token.OutPrompt: '#ansibrightred', | ||||
Token.OutPromptNum: '#ansired bold', | ||||
|
r22578 | } | ||
|
r22549 | def get_default_editor(): | ||
try: | ||||
|
r23085 | return os.environ['EDITOR'] | ||
|
r22549 | except KeyError: | ||
pass | ||||
except UnicodeError: | ||||
warn("$EDITOR environment variable is not pure ASCII. Using platform " | ||||
"default editor.") | ||||
if os.name == 'posix': | ||||
return 'vi' # the only one guaranteed to be there! | ||||
else: | ||||
return 'notepad' # same in Windows! | ||||
|
r22758 | # conservatively check for tty | ||
# overridden streams can result in things like: | ||||
# - sys.stdin = None | ||||
# - no isatty method | ||||
for _name in ('stdin', 'stdout', 'stderr'): | ||||
_stream = getattr(sys, _name) | ||||
if not _stream or not hasattr(_stream, 'isatty') or not _stream.isatty(): | ||||
_is_tty = False | ||||
break | ||||
|
r22549 | else: | ||
|
r22758 | _is_tty = True | ||
|
r22549 | |||
_use_simple_prompt = ('IPY_TEST_SIMPLE_PROMPT' in os.environ) or (not _is_tty) | ||||
|
r25142 | def black_reformat_handler(text_before_cursor): | ||
|
r27324 | """ | ||
We do not need to protect against error, | ||||
this is taken care at a higher level where any reformat error is ignored. | ||||
Indeed we may call reformatting on incomplete code. | ||||
""" | ||||
|
r25142 | import black | ||
|
r27324 | |||
|
r25142 | formatted_text = black.format_str(text_before_cursor, mode=black.FileMode()) | ||
|
r27324 | if not text_before_cursor.endswith("\n") and formatted_text.endswith("\n"): | ||
formatted_text = formatted_text[:-1] | ||||
|
r25142 | return formatted_text | ||
|
r22549 | class TerminalInteractiveShell(InteractiveShell): | ||
|
r25164 | mime_renderers = Dict().tag(config=True) | ||
|
r22549 | space_for_menu = Integer(6, help='Number of line at the bottom of the screen ' | ||
|
r25752 | 'to reserve for the tab completion menu, ' | ||
'search history, ...etc, the height of ' | ||||
'these menus will at most this value. ' | ||||
'Increase it is you prefer long and skinny ' | ||||
'menus, decrease for short and wide.' | ||||
|
r22549 | ).tag(config=True) | ||
|
r24376 | pt_app = None | ||
|
r22549 | debugger_history = None | ||
|
r26809 | debugger_history_file = Unicode( | ||
"~/.pdbhistory", help="File in which to store and read history" | ||||
).tag(config=True) | ||||
|
r22549 | simple_prompt = Bool(_use_simple_prompt, | ||
|
r23704 | help="""Use `raw_input` for the REPL, without completion and prompt colors. | ||
|
r22549 | |||
Useful when controlling IPython as a subprocess, and piping STDIN/OUT/ERR. Known usage are: | ||||
IPython own testing machinery, and emacs inferior-shell integration through elpy. | ||||
This mode default to `True` if the `IPY_TEST_SIMPLE_PROMPT` | ||||
|
r23477 | environment variable is set, or the current terminal is not a tty.""" | ||
|
r22549 | ).tag(config=True) | ||
@property | ||||
def debugger_cls(self): | ||||
return Pdb if self.simple_prompt else TerminalPdb | ||||
confirm_exit = Bool(True, | ||||
help=""" | ||||
Set to confirm when you try to exit IPython with an EOF (Control-D | ||||
in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit', | ||||
you can force a direct exit without any confirmation.""", | ||||
).tag(config=True) | ||||
editing_mode = Unicode('emacs', | ||||
help="Shortcut style to use at the prompt. 'vi' or 'emacs'.", | ||||
).tag(config=True) | ||||
|
r26091 | emacs_bindings_in_vi_insert_mode = Bool( | ||
True, | ||||
|
r26067 | help="Add shortcuts from 'emacs' insert mode to 'vi' insert mode.", | ||
).tag(config=True) | ||||
|
r26113 | modal_cursor = Bool( | ||
True, | ||||
help=""" | ||||
Cursor shape changes depending on vi mode: beam in vi insert mode, | ||||
block in nav mode, underscore in replace mode.""", | ||||
).tag(config=True) | ||||
ttimeoutlen = Float( | ||||
0.01, | ||||
help="""The time in milliseconds that is waited for a key code | ||||
to complete.""", | ||||
).tag(config=True) | ||||
timeoutlen = Float( | ||||
0.5, | ||||
help="""The time in milliseconds that is waited for a mapped key | ||||
sequence to complete.""", | ||||
).tag(config=True) | ||||
|
r27324 | autoformatter = Unicode( | ||
"black", | ||||
|
r25142 | help="Autoformatter to reformat Terminal code. Can be `'black'` or `None`", | ||
allow_none=True | ||||
).tag(config=True) | ||||
|
r22549 | mouse_support = Bool(False, | ||
|
r23846 | help="Enable mouse support in the prompt\n(Note: prevents selecting text with the mouse)" | ||
|
r22549 | ).tag(config=True) | ||
|
r23994 | # We don't load the list of styles for the help string, because loading | ||
# Pygments plugins takes time and can cause unexpected errors. | ||||
|
r22766 | highlighting_style = Union([Unicode('legacy'), Type(klass=Style)], | ||
help="""The name or class of a Pygments style to use for syntax | ||||
|
r23994 | highlighting. To see available styles, run `pygmentize -L styles`.""" | ||
|
r22549 | ).tag(config=True) | ||
|
r24684 | @validate('editing_mode') | ||
def _validate_editing_mode(self, proposal): | ||||
if proposal['value'].lower() == 'vim': | ||||
proposal['value']= 'vi' | ||||
elif proposal['value'].lower() == 'default': | ||||
proposal['value']= 'emacs' | ||||
if hasattr(EditingMode, proposal['value'].upper()): | ||||
return proposal['value'].lower() | ||||
return self.editing_mode | ||||
|
r26746 | |||
@observe('editing_mode') | ||||
|
r26747 | def _editing_mode(self, change): | ||
|
r24718 | if self.pt_app: | ||
|
r26748 | self.pt_app.editing_mode = getattr(EditingMode, change.new.upper()) | ||
|
r22859 | |||
|
r27324 | def _set_formatter(self, formatter): | ||
|
r25142 | if formatter is None: | ||
self.reformat_handler = lambda x:x | ||||
elif formatter == 'black': | ||||
self.reformat_handler = black_reformat_handler | ||||
else: | ||||
raise ValueError | ||||
|
r27324 | @observe("autoformatter") | ||
def _autoformatter_changed(self, change): | ||||
formatter = change.new | ||||
self._set_formatter(formatter) | ||||
|
r22549 | @observe('highlighting_style') | ||
|
r22578 | @observe('colors') | ||
|
r22549 | def _highlighting_style_changed(self, change): | ||
|
r22578 | self.refresh_style() | ||
def refresh_style(self): | ||||
|
r22766 | self._style = self._make_style_from_name_or_cls(self.highlighting_style) | ||
|
r22549 | |||
|
r22578 | |||
|
r22549 | highlighting_style_overrides = Dict( | ||
help="Override highlighting format for specific tokens" | ||||
).tag(config=True) | ||||
|
r22682 | true_color = Bool(False, | ||
|
r26122 | help="""Use 24bit colors instead of 256 colors in prompt highlighting. | ||
If your terminal supports true color, the following command should | ||||
print ``TRUECOLOR`` in orange:: | ||||
printf \"\\x1b[38;2;255;100;0mTRUECOLOR\\x1b[0m\\n\" | ||||
""", | ||||
|
r22682 | ).tag(config=True) | ||
|
r22549 | editor = Unicode(get_default_editor(), | ||
help="Set the editor used by IPython (default to $EDITOR/vi/notepad)." | ||||
).tag(config=True) | ||||
prompts_class = Type(Prompts, help='Class used to generate Prompt token for prompt_toolkit').tag(config=True) | ||||
prompts = Instance(Prompts) | ||||
@default('prompts') | ||||
def _prompts_default(self): | ||||
return self.prompts_class(self) | ||||
|
r24376 | # @observe('prompts') | ||
# def _(self, change): | ||||
# self._update_layout() | ||||
|
r22549 | |||
@default('displayhook_class') | ||||
def _displayhook_class_default(self): | ||||
return RichPromptDisplayHook | ||||
term_title = Bool(True, | ||||
help="Automatically set the terminal title" | ||||
).tag(config=True) | ||||
|
r23623 | term_title_format = Unicode("IPython: {cwd}", | ||
help="Customize the terminal title format. This is a python format string. " + | ||||
"Available substitutions are: {cwd}." | ||||
).tag(config=True) | ||||
|
r22859 | display_completions = Enum(('column', 'multicolumn','readlinelike'), | ||
|
r22726 | help= ( "Options for displaying tab completions, 'column', 'multicolumn', and " | ||
"'readlinelike'. These options are for `prompt_toolkit`, see " | ||||
"`prompt_toolkit` documentation for more information." | ||||
|
r22720 | ), | ||
default_value='multicolumn').tag(config=True) | ||||
|
r22554 | |||
|
r22549 | highlight_matching_brackets = Bool(True, | ||
|
r23409 | help="Highlight matching brackets.", | ||
).tag(config=True) | ||||
extra_open_editor_shortcuts = Bool(False, | ||||
help="Enable vi (v) or Emacs (C-X C-E) shortcuts to open an external editor. " | ||||
"This is in addition to the F2 binding, which is always enabled." | ||||
|
r22549 | ).tag(config=True) | ||
|
r23580 | handle_return = Any(None, | ||
help="Provide an alternative handler to be called when the user presses " | ||||
"Return. This is an advanced option intended for debugging, which " | ||||
"may be changed or removed in later releases." | ||||
).tag(config=True) | ||||
|
r24147 | enable_history_search = Bool(True, | ||
help="Allows to enable/disable the prompt toolkit history search" | ||||
).tag(config=True) | ||||
|
r24832 | prompt_includes_vi_mode = Bool(True, | ||
help="Display the current vi mode (when using vi editing mode)." | ||||
).tag(config=True) | ||||
|
r22549 | @observe('term_title') | ||
def init_term_title(self, change=None): | ||||
# Enable or disable the terminal title. | ||||
if self.term_title: | ||||
toggle_set_term_title(True) | ||||
|
r23623 | set_term_title(self.term_title_format.format(cwd=abbrev_cwd())) | ||
|
r22549 | else: | ||
toggle_set_term_title(False) | ||||
|
r25194 | def restore_term_title(self): | ||
if self.term_title: | ||||
restore_term_title() | ||||
|
r22549 | def init_display_formatter(self): | ||
super(TerminalInteractiveShell, self).init_display_formatter() | ||||
# terminal only supports plain text | ||||
self.display_formatter.active_types = ['text/plain'] | ||||
|
r23307 | # disable `_ipython_display_` | ||
self.display_formatter.ipython_display_formatter.enabled = False | ||||
|
r22549 | |||
def init_prompt_toolkit_cli(self): | ||||
if self.simple_prompt: | ||||
# Fall back to plain non-interactive output for tests. | ||||
|
r24167 | # This is very limited. | ||
|
r22549 | def prompt(): | ||
|
r23705 | prompt_text = "".join(x[1] for x in self.prompts.in_prompt_tokens()) | ||
|
r24167 | lines = [input(prompt_text)] | ||
|
r23705 | prompt_continuation = "".join(x[1] for x in self.prompts.continuation_prompt_tokens()) | ||
|
r24180 | while self.check_complete('\n'.join(lines))[0] == 'incomplete': | ||
|
r24167 | lines.append( input(prompt_continuation) ) | ||
return '\n'.join(lines) | ||||
|
r22549 | self.prompt_for_code = prompt | ||
return | ||||
|
r22642 | # Set up keyboard shortcuts | ||
|
r24376 | key_bindings = create_ipython_shortcuts(self) | ||
|
r22549 | |||
# Pre-populate history from IPython's history database | ||||
history = InMemoryHistory() | ||||
last_cell = u"" | ||||
for __, ___, cell in self.history_manager.get_tail(self.history_load_length, | ||||
include_latest=True): | ||||
# Ignore blank lines and consecutive duplicates | ||||
cell = cell.rstrip() | ||||
if cell and (cell != last_cell): | ||||
|
r24376 | history.append_string(cell) | ||
|
r22859 | last_cell = cell | ||
|
r22549 | |||
|
r22766 | self._style = self._make_style_from_name_or_cls(self.highlighting_style) | ||
|
r23571 | self.style = DynamicStyle(lambda: self._style) | ||
|
r22549 | |||
editing_mode = getattr(EditingMode, self.editing_mode.upper()) | ||||
|
r25276 | self.pt_loop = asyncio.new_event_loop() | ||
|
r24376 | self.pt_app = PromptSession( | ||
|
r26104 | auto_suggest=AutoSuggestFromHistory(), | ||
editing_mode=editing_mode, | ||||
key_bindings=key_bindings, | ||||
history=history, | ||||
completer=IPythonPTCompleter(shell=self), | ||||
enable_history_search=self.enable_history_search, | ||||
style=self.style, | ||||
include_default_pygments_style=False, | ||||
mouse_support=self.mouse_support, | ||||
enable_open_in_editor=self.extra_open_editor_shortcuts, | ||||
color_depth=self.color_depth, | ||||
tempfile_suffix=".py", | ||||
**self._extra_prompt_options() | ||||
) | ||||
|
r22549 | |||
|
r22766 | def _make_style_from_name_or_cls(self, name_or_cls): | ||
|
r22549 | """ | ||
Small wrapper that make an IPython compatible style from a style name | ||||
|
r22859 | We need that to add style for prompt ... etc. | ||
|
r22549 | """ | ||
|
r22609 | style_overrides = {} | ||
|
r22766 | if name_or_cls == 'legacy': | ||
|
r22578 | legacy = self.colors.lower() | ||
if legacy == 'linux': | ||||
style_cls = get_style_by_name('monokai') | ||||
style_overrides = _style_overrides_linux | ||||
elif legacy == 'lightbg': | ||||
style_overrides = _style_overrides_light_bg | ||||
|
r22609 | style_cls = get_style_by_name('pastie') | ||
elif legacy == 'neutral': | ||||
|
r22578 | # The default theme needs to be visible on both a dark background | ||
# and a light background, because we can't tell what the terminal | ||||
# looks like. These tweaks to the default theme help with that. | ||||
|
r22609 | style_cls = get_style_by_name('default') | ||
|
r22578 | style_overrides.update({ | ||
|
r25894 | Token.Number: '#ansigreen', | ||
|
r22578 | Token.Operator: 'noinherit', | ||
|
r25894 | Token.String: '#ansiyellow', | ||
Token.Name.Function: '#ansiblue', | ||||
Token.Name.Class: 'bold #ansiblue', | ||||
Token.Name.Namespace: 'bold #ansiblue', | ||||
|
r25896 | Token.Name.Variable.Magic: '#ansiblue', | ||
|
r25894 | Token.Prompt: '#ansigreen', | ||
|
r24680 | Token.PromptNum: '#ansibrightgreen bold', | ||
|
r25894 | Token.OutPrompt: '#ansired', | ||
|
r24680 | Token.OutPromptNum: '#ansibrightred bold', | ||
|
r22578 | }) | ||
|
r23317 | |||
# Hack: Due to limited color support on the Windows console | ||||
# the prompt colors will be wrong without this | ||||
if os.name == 'nt': | ||||
style_overrides.update({ | ||||
Token.Prompt: '#ansidarkgreen', | ||||
Token.PromptNum: '#ansigreen bold', | ||||
Token.OutPrompt: '#ansidarkred', | ||||
Token.OutPromptNum: '#ansired bold', | ||||
}) | ||||
|
r22578 | elif legacy =='nocolor': | ||
style_cls=_NoStyle | ||||
style_overrides = {} | ||||
else : | ||||
raise ValueError('Got unknown colors: ', legacy) | ||||
else : | ||||
|
r23037 | if isinstance(name_or_cls, str): | ||
|
r22766 | style_cls = get_style_by_name(name_or_cls) | ||
else: | ||||
style_cls = name_or_cls | ||||
|
r22578 | style_overrides = { | ||
|
r25894 | Token.Prompt: '#ansigreen', | ||
|
r24680 | Token.PromptNum: '#ansibrightgreen bold', | ||
|
r25894 | Token.OutPrompt: '#ansired', | ||
|
r24680 | Token.OutPromptNum: '#ansibrightred bold', | ||
|
r22578 | } | ||
|
r22549 | style_overrides.update(self.highlighting_style_overrides) | ||
|
r24376 | style = merge_styles([ | ||
style_from_pygments_cls(style_cls), | ||||
style_from_pygments_dict(style_overrides), | ||||
]) | ||||
|
r22549 | |||
return style | ||||
|
r24376 | @property | ||
def pt_complete_style(self): | ||||
return { | ||||
'multicolumn': CompleteStyle.MULTI_COLUMN, | ||||
'column': CompleteStyle.COLUMN, | ||||
'readlinelike': CompleteStyle.READLINE_LIKE, | ||||
|
r24397 | }[self.display_completions] | ||
|
r24376 | |||
|
r24902 | @property | ||
def color_depth(self): | ||||
return (ColorDepth.TRUE_COLOR if self.true_color else None) | ||||
|
r24376 | def _extra_prompt_options(self): | ||
|
r22549 | """ | ||
Return the current layout option for the current Terminal InteractiveShell | ||||
""" | ||||
|
r25219 | def get_message(): | ||
return PygmentsTokens(self.prompts.in_prompt_tokens()) | ||||
if self.editing_mode == 'emacs': | ||||
# with emacs mode the prompt is (usually) static, so we call only | ||||
# the function once. With VI mode it can toggle between [ins] and | ||||
# [nor] so we can't precompute. | ||||
# here I'm going to favor the default keybinding which almost | ||||
# everybody uses to decrease CPU usage. | ||||
# if we have issues with users with custom Prompts we can see how to | ||||
# work around this. | ||||
get_message = get_message() | ||||
|
r24376 | |||
|
r25268 | options = { | ||
|
r24376 | 'complete_in_thread': False, | ||
|
r22549 | 'lexer':IPythonPTLexer(), | ||
'reserve_space_for_menu':self.space_for_menu, | ||||
|
r25219 | 'message': get_message, | ||
|
r24376 | 'prompt_continuation': ( | ||
lambda width, lineno, is_soft_wrap: | ||||
PygmentsTokens(self.prompts.continuation_prompt_tokens(width))), | ||||
'multiline': True, | ||||
'complete_style': self.pt_complete_style, | ||||
|
r22549 | |||
# Highlight matching brackets, but only when this setting is | ||||
# enabled, and only when the DEFAULT_BUFFER has the focus. | ||||
|
r24376 | 'input_processors': [ConditionalProcessor( | ||
|
r22549 | processor=HighlightMatchingBracketProcessor(chars='[](){}'), | ||
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() & | ||||
|
r24376 | Condition(lambda: self.highlight_matching_brackets))], | ||
|
r22549 | } | ||
|
r25268 | if not PTK3: | ||
|
r25325 | options['inputhook'] = self.inputhook | ||
|
r25268 | |||
return options | ||||
|
r22549 | |||
def prompt_for_code(self): | ||||
|
r24376 | if self.rl_next_input: | ||
default = self.rl_next_input | ||||
self.rl_next_input = None | ||||
else: | ||||
default = '' | ||||
|
r25309 | # In order to make sure that asyncio code written in the | ||
# interactive shell doesn't interfere with the prompt, we run the | ||||
# prompt in a different event loop. | ||||
# If we don't do this, people could spawn coroutine with a | ||||
# while/true inside which will freeze the prompt. | ||||
|
r25276 | |||
|
r27192 | policy = asyncio.get_event_loop_policy() | ||
|
r25309 | try: | ||
|
r27192 | old_loop = policy.get_event_loop() | ||
|
r25309 | except RuntimeError: | ||
|
r27192 | # This happens when the the event loop is closed, | ||
# e.g. by calling `asyncio.run()`. | ||||
|
r25309 | old_loop = None | ||
|
r27192 | policy.set_event_loop(self.pt_loop) | ||
|
r25309 | try: | ||
with patch_stdout(raw=True): | ||||
|
r25276 | text = self.pt_app.prompt( | ||
default=default, | ||||
**self._extra_prompt_options()) | ||||
|
r25309 | finally: | ||
# Restore the original event loop. | ||||
|
r27192 | if old_loop is not None: | ||
policy.set_event_loop(old_loop) | ||||
|
r25309 | |||
|
r24376 | return text | ||
|
r22549 | |||
|
r25247 | def enable_win_unicode_console(self): | ||
# Since IPython 7.10 doesn't support python < 3.6 and PEP 528, Python uses the unicode APIs for the Windows | ||||
# console by default, so WUC shouldn't be needed. | ||||
from warnings import warn | ||||
warn("`enable_win_unicode_console` is deprecated since IPython 7.10, does not do anything and will be removed in the future", | ||||
DeprecationWarning, | ||||
stacklevel=2) | ||||
|
r22549 | def init_io(self): | ||
if sys.platform not in {'win32', 'cli'}: | ||||
return | ||||
|
r22701 | import colorama | ||
|
r22549 | colorama.init() | ||
def init_magics(self): | ||||
super(TerminalInteractiveShell, self).init_magics() | ||||
self.register_magics(TerminalMagics) | ||||
def init_alias(self): | ||||
# The parent class defines aliases that can be safely used with any | ||||
# frontend. | ||||
super(TerminalInteractiveShell, self).init_alias() | ||||
# Now define aliases that only make sense on the terminal, because they | ||||
# need direct access to the console in a way that we can't emulate in | ||||
# GUI or web frontend | ||||
if os.name == 'posix': | ||||
|
r24889 | for cmd in ('clear', 'more', 'less', 'man'): | ||
|
r22549 | self.alias_manager.soft_define_alias(cmd, cmd) | ||
|
r5435 | |||
|
r22442 | |||
|
r22436 | def __init__(self, *args, **kwargs): | ||
|
r22549 | super(TerminalInteractiveShell, self).__init__(*args, **kwargs) | ||
self.init_prompt_toolkit_cli() | ||||
self.init_term_title() | ||||
self.keep_running = True | ||||
|
r27324 | self._set_formatter(self.autoformatter) | ||
|
r22549 | |||
def ask_exit(self): | ||||
self.keep_running = False | ||||
rl_next_input = None | ||||
|
r27216 | def interact(self): | ||
|
r22764 | self.keep_running = True | ||
|
r22549 | while self.keep_running: | ||
print(self.separate_in, end='') | ||||
try: | ||||
code = self.prompt_for_code() | ||||
except EOFError: | ||||
if (not self.confirm_exit) \ | ||||
or self.ask_yes_no('Do you really want to exit ([y]/n)?','y','n'): | ||||
self.ask_exit() | ||||
else: | ||||
if code: | ||||
self.run_cell(code, store_history=True) | ||||
|
r27216 | def mainloop(self): | ||
|
r22549 | # An extra layer of protection in case someone mashing Ctrl-C breaks | ||
# out of our internal code. | ||||
while True: | ||||
try: | ||||
self.interact() | ||||
break | ||||
|
r23258 | except KeyboardInterrupt as e: | ||
print("\n%s escaped interact()\n" % type(e).__name__) | ||||
|
r23259 | finally: | ||
|
r23258 | # An interrupt during the eventloop will mess up the | ||
# internal state of the prompt_toolkit library. | ||||
# Stopping the eventloop fixes this, see | ||||
# https://github.com/ipython/ipython/pull/9867 | ||||
if hasattr(self, '_eventloop'): | ||||
self._eventloop.stop() | ||||
|
r22549 | |||
|
r25194 | self.restore_term_title() | ||
|
r26428 | # try to call some at-exit operation optimistically as some things can't | ||
# be done during interpreter shutdown. this is technically inaccurate as | ||||
# this make mainlool not re-callable, but that should be a rare if not | ||||
# in existent use case. | ||||
self._atexit_once() | ||||
|
r25194 | |||
|
r22549 | _inputhook = None | ||
def inputhook(self, context): | ||||
if self._inputhook is not None: | ||||
self._inputhook(context) | ||||
|
r22913 | active_eventloop = None | ||
|
r22549 | def enable_gui(self, gui=None): | ||
|
r25241 | if gui and (gui != 'inline') : | ||
|
r22913 | self.active_eventloop, self._inputhook =\ | ||
get_inputhook_name_and_func(gui) | ||||
|
r22549 | else: | ||
|
r22913 | self.active_eventloop = self._inputhook = None | ||
|
r22549 | |||
|
r25268 | # For prompt_toolkit 3.0. We have to create an asyncio event loop with | ||
# this inputhook. | ||||
if PTK3: | ||||
|
r25308 | import asyncio | ||
from prompt_toolkit.eventloop import new_eventloop_with_inputhook | ||||
if gui == 'asyncio': | ||||
# When we integrate the asyncio event loop, run the UI in the | ||||
# same event loop as the rest of the code. don't use an actual | ||||
# input hook. (Asyncio is not made for nesting event loops.) | ||||
|
r27072 | self.pt_loop = asyncio.get_event_loop_policy().get_event_loop() | ||
|
r25308 | |||
elif self._inputhook: | ||||
# If an inputhook was set, create a new asyncio event loop with | ||||
# this inputhook for the prompt. | ||||
|
r25276 | self.pt_loop = new_eventloop_with_inputhook(self._inputhook) | ||
|
r25268 | else: | ||
|
r25308 | # When there's no inputhook, run the prompt in a separate | ||
# asyncio event loop. | ||||
|
r25276 | self.pt_loop = asyncio.new_event_loop() | ||
|
r25268 | |||
|
r22549 | # Run !system commands directly, not through pipes, so terminal programs | ||
# work correctly. | ||||
system = InteractiveShell.system_raw | ||||
def auto_rewrite_input(self, cmd): | ||||
"""Overridden from the parent class to use fancy rewriting prompt""" | ||||
if not self.show_rewritten_input: | ||||
return | ||||
tokens = self.prompts.rewrite_prompt_tokens() | ||||
|
r24376 | if self.pt_app: | ||
|
r24379 | print_formatted_text(PygmentsTokens(tokens), end='', | ||
style=self.pt_app.app.style) | ||||
|
r22549 | print(cmd) | ||
else: | ||||
prompt = ''.join(s for t, s in tokens) | ||||
print(prompt, cmd, sep='') | ||||
_prompts_before = None | ||||
def switch_doctest_mode(self, mode): | ||||
"""Switch prompts to classic for %doctest_mode""" | ||||
if mode: | ||||
self._prompts_before = self.prompts | ||||
self.prompts = ClassicPrompts(self) | ||||
elif self._prompts_before: | ||||
self.prompts = self._prompts_before | ||||
self._prompts_before = None | ||||
|
r24376 | # self._update_layout() | ||
|
r22549 | |||
InteractiveShellABC.register(TerminalInteractiveShell) | ||||
if __name__ == '__main__': | ||||
TerminalInteractiveShell.instance().interact() | ||||