def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.wrap_action = None
self.editors = []
self.filenames = []
self.icons = []
if PYQT5:
SpyderPluginWidget.__init__(self, parent, main=parent)
else:
SpyderPluginWidget.__init__(self, parent)
# Initialize plugin
self.initialize_plugin()
self.set_default_color_scheme()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.tabwidget.currentChanged.connect(self.refresh_plugin)
self.tabwidget.move_data.connect(self.move_tab)
if sys.platform == 'darwin':
tab_container = QWidget()
tab_container.setObjectName('tab-container')
tab_layout = QHBoxLayout(tab_container)
tab_layout.setContentsMargins(0, 0, 0, 0)
tab_layout.addWidget(self.tabwidget)
layout.addWidget(tab_container)
else:
layout.addWidget(self.tabwidget)
self.tabwidget.setStyleSheet("QTabWidget::pane {border: 0;}")
# Menu as corner widget
options_button = create_toolbutton(self,
text=_('Options'),
icon=ima.icon('tooloptions'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.editors = []
self.filenames = []
self.icons = []
SpyderPluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self, text=self.tr("Options"),
icon=get_icon('tooloptions.png'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.wrap_action = None
self.editors = []
self.filenames = []
self.icons = []
SpyderPluginWidget.__init__(self, parent)
# Initialize plugin
self.initialize_plugin()
self.set_default_color_scheme()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self,
text=_("Options"),
icon=get_icon('tooloptions.png'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
def __init__(self, parent):
SpyderPluginWidget.__init__(self, parent)
self.tabwidget = None
self.menu_actions = None
self.extconsole = None # External console plugin
self.inspector = None # Object inspector plugin
self.historylog = None # History log plugin
self.variableexplorer = None # Variable explorer plugin
self.clients = []
# Initialize plugin
self.initialize_plugin()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
if hasattr(self.tabwidget, 'setDocumentMode')\
and not sys.platform == 'darwin':
# Don't set document mode to true on OSX because it generates
# a crash when the console is detached from the main window
# Fixes Issue 561
self.tabwidget.setDocumentMode(True)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.tabwidget.set_close_function(self.close_client)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.wrap_action = None
self.editors = []
self.filenames = []
self.icons = []
if PYQT5:
SpyderPluginWidget.__init__(self, parent, main = parent)
else:
SpyderPluginWidget.__init__(self, parent)
# Initialize plugin
self.initialize_plugin()
self.set_default_color_scheme()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.tabwidget.currentChanged.connect(self.refresh_plugin)
self.tabwidget.move_data.connect(self.move_tab)
if sys.platform == 'darwin':
tab_container = QWidget()
tab_container.setObjectName('tab-container')
tab_layout = QHBoxLayout(tab_container)
tab_layout.setContentsMargins(0, 0, 0, 0)
tab_layout.addWidget(self.tabwidget)
layout.addWidget(tab_container)
else:
layout.addWidget(self.tabwidget)
self.tabwidget.setStyleSheet("QTabWidget::pane {border: 0;}")
# Menu as corner widget
options_button = create_toolbutton(self, text=_('Options'),
icon=ima.icon('tooloptions'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
def __init__(self, parent, commands=None):
self.commands = commands
self.tabwidget = None
self.menu_actions = None
self.docviewer = None
self.historylog = None
self.shells = []
self.filenames = []
self.icons = []
PluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh)
self.connect(self.tabwidget, SIGNAL("close_tab(int)"),
self.tabwidget.removeTab)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.close_button = create_toolbutton(
self.tabwidget,
icon=get_icon("fileclose.png"),
triggered=self.close_console,
tip=self.tr("Close current console"))
self.tabwidget.setCornerWidget(self.close_button)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.editors = []
self.filenames = []
self.icons = []
PluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh)
self.connect(self.tabwidget, SIGNAL("close_tab(int)"),
self.tabwidget.removeTab)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self,
text=self.tr("Options"),
icon=get_icon('tooloptions.png'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
def __init__(self, parent, light_mode):
self.light_mode = light_mode
self.commands = []
self.tabwidget = None
self.menu_actions = None
self.inspector = None
self.historylog = None
self.variableexplorer = None # variable explorer plugin
self.ipython_count = 0
self.python_count = 0
self.terminal_count = 0
if CONF.get(self.ID, 'ipython_options', None) is None:
CONF.set(self.ID, 'ipython_options',
self.get_default_ipython_options())
self.shells = []
self.filenames = []
self.icons = []
SpyderPluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.tabwidget.set_close_function(self.close_console)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
def __init__(self, parent):
SpyderPluginWidget.__init__(self, parent)
self.tabwidget = None
self.menu_actions = None
self.extconsole = None # External console plugin
self.inspector = None # Object inspector plugin
self.historylog = None # History log plugin
self.variableexplorer = None # Variable explorer plugin
self.clients = []
# Initialize plugin
self.initialize_plugin()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
if hasattr(self.tabwidget, 'setDocumentMode')\
and not sys.platform == 'darwin':
# Don't set document mode to true on OSX because it generates
# a crash when the console is detached from the main window
# Fixes Issue 561
self.tabwidget.setDocumentMode(True)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.tabwidget.set_close_function(self.close_client)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.wrap_action = None
self.editors = []
self.filenames = []
self.icons = []
if PYQT5:
SpyderPluginWidget.__init__(self, parent, main = parent)
else:
SpyderPluginWidget.__init__(self, parent)
# Initialize plugin
self.initialize_plugin()
self.set_default_color_scheme()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.tabwidget.currentChanged.connect(self.refresh_plugin)
self.tabwidget.move_data.connect(self.move_tab)
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self, text=_('Options'),
icon=ima.icon('tooloptions'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
def __init__(self, parent, commands=None):
self.commands = commands
self.tabwidget = None
self.menu_actions = None
self.docviewer = None
self.historylog = None
self.shells = []
self.filenames = []
self.icons = []
PluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh)
self.connect(self.tabwidget, SIGNAL("close_tab(int)"),
self.tabwidget.removeTab)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.close_button = create_toolbutton(self.tabwidget,
icon=get_icon("fileclose.png"),
triggered=self.close_console,
tip=self.tr("Close current console"))
self.tabwidget.setCornerWidget(self.close_button)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
class HistoryLog(SpyderPluginWidget):
"""
History log widget
"""
CONF_SECTION = 'historylog'
CONFIGWIDGET_CLASS = HistoryConfigPage
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.wrap_action = None
self.editors = []
self.filenames = []
self.icons = []
SpyderPluginWidget.__init__(self, parent)
# Initialize plugin
self.initialize_plugin()
self.set_default_color_scheme()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self,
text=_("Options"),
icon=get_icon('tooloptions.png'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
#------ SpyderPluginWidget API ---------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return _('History log')
def get_plugin_icon(self):
"""Return widget icon"""
return get_icon('history.png')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.tabwidget.currentWidget()
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
return True
def refresh_plugin(self):
"""Refresh tabwidget"""
if self.tabwidget.count():
editor = self.tabwidget.currentWidget()
else:
editor = None
self.find_widget.set_editor(editor)
def get_plugin_actions(self):
"""Return a list of actions related to plugin"""
history_action = create_action(self,
_("History..."),
None,
'history.png',
_("Set history maximum entries"),
triggered=self.change_history_depth)
font_action = create_action(self,
_("&Font..."),
None,
'font.png',
_("Set shell font style"),
triggered=self.change_font)
self.wrap_action = create_action(self,
_("Wrap lines"),
toggled=self.toggle_wrap_mode)
self.wrap_action.setChecked(self.get_option('wrap'))
self.menu_actions = [history_action, font_action, self.wrap_action]
return self.menu_actions
def on_first_registration(self):
"""Action to be performed on first plugin registration"""
self.main.tabify_plugins(self.main.extconsole, self)
def register_plugin(self):
"""Register plugin in Spyder's main window"""
self.connect(self, SIGNAL('focus_changed()'),
self.main.plugin_focus_changed)
self.main.add_dockwidget(self)
# self.main.console.set_historylog(self)
self.connect(self.main.console.shell, SIGNAL("refresh()"),
self.refresh_plugin)
def apply_plugin_settings(self, options):
"""Apply configuration file's plugin settings"""
color_scheme_n = 'color_scheme_name'
color_scheme_o = get_color_scheme(self.get_option(color_scheme_n))
font_n = 'plugin_font'
font_o = self.get_plugin_font()
wrap_n = 'wrap'
wrap_o = self.get_option(wrap_n)
self.wrap_action.setChecked(wrap_o)
for editor in self.editors:
if font_n in options:
scs = color_scheme_o if color_scheme_n in options else None
editor.set_font(font_o, scs)
elif color_scheme_n in options:
editor.set_color_scheme(color_scheme_o)
if wrap_n in options:
editor.toggle_wrap_mode(wrap_o)
#------ Private API --------------------------------------------------------
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
filename = self.filenames.pop(index_from)
editor = self.editors.pop(index_from)
icon = self.icons.pop(index_from)
self.filenames.insert(index_to, filename)
self.editors.insert(index_to, editor)
self.icons.insert(index_to, icon)
#------ Public API ---------------------------------------------------------
def add_history(self, filename):
"""
Add new history tab
Slot for SIGNAL('add_history(QString)') emitted by shell instance
"""
filename = encoding.to_unicode_from_fs(filename)
if filename in self.filenames:
return
editor = codeeditor.CodeEditor(self)
if osp.splitext(filename)[1] == '.py':
language = 'py'
icon = get_icon('python.png')
else:
language = 'bat'
icon = get_icon('cmdprompt.png')
editor.setup_editor(linenumbers=False,
language=language,
scrollflagarea=False)
self.connect(editor, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
editor.setReadOnly(True)
color_scheme = get_color_scheme(self.get_option('color_scheme_name'))
editor.set_font(self.get_plugin_font(), color_scheme)
editor.toggle_wrap_mode(self.get_option('wrap'))
text, _ = encoding.read(filename)
editor.set_text(text)
editor.set_cursor_position('eof')
self.editors.append(editor)
self.filenames.append(filename)
self.icons.append(icon)
index = self.tabwidget.addTab(editor, osp.basename(filename))
self.find_widget.set_editor(editor)
self.tabwidget.setTabToolTip(index, filename)
self.tabwidget.setTabIcon(index, icon)
self.tabwidget.setCurrentIndex(index)
def append_to_history(self, filename, command):
"""
Append an entry to history filename
Slot for SIGNAL('append_to_history(QString,QString)')
emitted by shell instance
"""
if not is_text_string(filename): # filename is a QString
filename = to_text_string(filename.toUtf8(), 'utf-8')
command = to_text_string(command)
index = self.filenames.index(filename)
self.editors[index].append(command)
if self.get_option('go_to_eof'):
self.editors[index].set_cursor_position('eof')
self.tabwidget.setCurrentIndex(index)
def change_history_depth(self):
"Change history max entries" ""
depth, valid = QInputDialog.getInteger(self, _('History'),
_('Maximum entries'),
self.get_option('max_entries'),
10, 10000)
if valid:
self.set_option('max_entries', depth)
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(self.get_plugin_font(), self,
_("Select a new font"))
if valid:
for editor in self.editors:
editor.set_font(font)
self.set_plugin_font(font)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
if self.tabwidget is None:
return
for editor in self.editors:
editor.toggle_wrap_mode(checked)
self.set_option('wrap', checked)
class ExternalConsole(PluginWidget):
"""
Console widget
"""
ID = 'external_shell'
location = Qt.RightDockWidgetArea
def __init__(self, parent, commands=None):
self.commands = commands
self.tabwidget = None
self.menu_actions = None
self.docviewer = None
self.historylog = None
self.shells = []
self.filenames = []
self.icons = []
PluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh)
self.connect(self.tabwidget, SIGNAL("close_tab(int)"),
self.tabwidget.removeTab)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.close_button = create_toolbutton(self.tabwidget,
icon=get_icon("fileclose.png"),
triggered=self.close_console,
tip=self.tr("Close current console"))
self.tabwidget.setCornerWidget(self.close_button)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
filename = self.filenames.pop(index_from)
shell = self.shells.pop(index_from)
icon = self.icons.pop(index_from)
self.filenames.insert(index_to, filename)
self.shells.insert(index_to, shell)
self.icons.insert(index_to, icon)
def close_console(self, index=None):
if not self.tabwidget.count():
return
if index is None:
index = self.tabwidget.currentIndex()
self.tabwidget.widget(index).close()
self.tabwidget.removeTab(index)
self.filenames.pop(index)
self.shells.pop(index)
self.icons.pop(index)
def set_historylog(self, historylog):
"""Bind historylog instance to this console"""
self.historylog = historylog
def set_docviewer(self, docviewer):
"""Bind docviewer instance to this console"""
self.docviewer = docviewer
def execute_python_code(self, lines):
"""Execute Python code in an already opened Python interpreter"""
from spyderlib.widgets.externalshell.pythonshell import ExtPyQsciShell
def execute(index):
shell = self.tabwidget.widget(index).shell
if isinstance(shell, ExtPyQsciShell):
self.tabwidget.setCurrentIndex(index)
shell.execute_lines(unicode(lines))
shell.setFocus()
return True
# Find the Python shell, starting with current widget:
current_index = self.tabwidget.currentIndex()
if current_index == -1:
# No shell!
return
if not execute(current_index):
for index in self.tabwidget.count():
execute(index)
def start(self, fname, wdir=None, ask_for_arguments=False,
interact=False, debug=False, python=True):
"""Start new console"""
# Note: fname is None <=> Python interpreter
fname = unicode(fname) if isinstance(fname, QString) else fname
wdir = unicode(wdir) if isinstance(wdir, QString) else wdir
if fname is not None and fname in self.filenames:
index = self.filenames.index(fname)
if CONF.get(self.ID, 'single_tab'):
old_shell = self.shells[index]
if old_shell.is_running():
answer = QMessageBox.question(self, self.get_widget_title(),
self.tr("%1 is already running in a separate process.\n"
"Do you want to kill the process before starting "
"a new one?").arg(osp.basename(fname)),
QMessageBox.Yes | QMessageBox.Cancel)
if answer == QMessageBox.Yes:
old_shell.process.kill()
old_shell.process.waitForFinished()
else:
return
self.close_console(index)
else:
index = 0
# Creating a new external shell
if python:
shell = ExternalPythonShell(self, fname, wdir, self.commands,
interact, debug, path=self.main.path)
else:
shell = ExternalSystemShell(self, wdir)
shell.shell.set_font( get_font(self.ID) )
shell.shell.toggle_wrap_mode( CONF.get(self.ID, 'wrap') )
shell.shell.set_calltips( CONF.get(self.ID, 'calltips') )
shell.shell.set_codecompletion( CONF.get(self.ID,
'autocompletion/enabled') )
shell.shell.set_codecompletion_enter(CONF.get(self.ID,
'autocompletion/enter-key'))
if python:
shell.shell.set_docviewer(self.docviewer)
self.historylog.add_history(shell.shell.history_filename)
self.connect(shell.shell, SIGNAL('append_to_history(QString,QString)'),
self.historylog.append_to_history)
self.connect(shell.shell, SIGNAL("go_to_error(QString)"),
self.go_to_error)
self.connect(shell.shell, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
if python:
if fname is None:
name = "Python"
icon = get_icon('python.png')
else:
name = osp.basename(fname)
icon = get_icon('run.png')
else:
name = "Command Window"
icon = get_icon('cmdprompt.png')
self.shells.insert(index, shell)
self.filenames.insert(index, fname)
self.icons.insert(index, icon)
if index is None:
index = self.tabwidget.addTab(shell, name)
else:
self.tabwidget.insertTab(index, shell, name)
self.connect(shell, SIGNAL("started()"),
lambda sid=id(shell): self.process_started(sid))
self.connect(shell, SIGNAL("finished()"),
lambda sid=id(shell): self.process_finished(sid))
self.find_widget.set_editor(shell.shell)
self.tabwidget.setTabToolTip(index, fname if wdir is None else wdir)
self.tabwidget.setCurrentIndex(index)
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
# Start process and give focus to console
shell.start(ask_for_arguments)
shell.shell.setFocus()
def process_started(self, shell_id):
for index, shell in enumerate(self.shells):
if id(shell) == shell_id:
self.tabwidget.setTabIcon(index, self.icons[index])
def process_finished(self, shell_id):
for index, shell in enumerate(self.shells):
if id(shell) == shell_id:
self.tabwidget.setTabIcon(index, get_icon('terminated.png'))
def get_widget_title(self):
"""Return widget title"""
return self.tr('External console')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.tabwidget.currentWidget()
def set_actions(self):
"""Setup actions"""
interpreter_action = create_action(self,
self.tr("Open &interpreter"), None,
'python.png', self.tr("Open a Python interpreter"),
triggered=self.open_interpreter)
if os.name == 'nt':
text = self.tr("Open &command prompt")
tip = self.tr("Open a Windows command prompt")
else:
text = self.tr("Open &command shell")
tip = self.tr("Open a shell window inside Spyder")
console_action = create_action(self, text, None, 'cmdprompt.png', tip,
triggered=self.open_console)
run_action = create_action(self,
self.tr("&Run..."), None,
'run_small.png', self.tr("Run a Python script"),
triggered=self.run_script)
font_action = create_action(self,
self.tr("&Font..."), None,
'font.png', self.tr("Set shell font style"),
triggered=self.change_font)
wrap_action = create_action(self,
self.tr("Wrap lines"),
toggled=self.toggle_wrap_mode)
wrap_action.setChecked( CONF.get(self.ID, 'wrap') )
calltips_action = create_action(self, self.tr("Balloon tips"),
toggled=self.toggle_calltips)
calltips_action.setChecked( CONF.get(self.ID, 'calltips') )
codecompletion_action = create_action(self, self.tr("Code completion"),
toggled=self.toggle_codecompletion)
codecompletion_action.setChecked( CONF.get(self.ID,
'autocompletion/enabled') )
codecompenter_action = create_action(self,
self.tr("Enter key selects completion"),
toggled=self.toggle_codecompletion_enter)
codecompenter_action.setChecked( CONF.get(self.ID,
'autocompletion/enter-key') )
singletab_action = create_action(self,
self.tr("One tab per script"),
toggled=self.toggle_singletab)
singletab_action.setChecked( CONF.get(self.ID, 'single_tab') )
self.menu_actions = [interpreter_action, run_action, None,
font_action, wrap_action, calltips_action,
codecompletion_action, codecompenter_action,
singletab_action]
if console_action:
self.menu_actions.insert(1, console_action)
return (self.menu_actions, None)
def open_interpreter(self):
"""Open interpreter"""
self.start(None, os.getcwdu(), False, True, False)
def open_console(self):
"""Open interpreter"""
self.start(None, os.getcwdu(), False, True, False, python=False)
def run_script(self):
"""Run a Python script"""
self.emit(SIGNAL('redirect_stdio(bool)'), False)
filename = QFileDialog.getOpenFileName(self,
self.tr("Run Python script"), os.getcwdu(),
self.tr("Python scripts")+" (*.py ; *.pyw)")
self.emit(SIGNAL('redirect_stdio(bool)'), True)
if filename:
self.start(unicode(filename), None, False, False, False)
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(get_font(self.ID),
self, self.tr("Select a new font"))
if valid:
for index in range(self.tabwidget.count()):
self.tabwidget.widget(index).shell.set_font(font)
set_font(font, self.ID)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.toggle_wrap_mode(checked)
CONF.set(self.ID, 'wrap', checked)
def toggle_calltips(self, checked):
"""Toggle calltips"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_calltips(checked)
CONF.set(self.ID, 'calltips', checked)
def toggle_codecompletion(self, checked):
"""Toggle code completion"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_codecompletion(checked)
CONF.set(self.ID, 'autocompletion/enabled', checked)
def toggle_codecompletion_enter(self, checked):
"""Toggle Enter key for code completion"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_codecompletion_enter(checked)
CONF.set(self.ID, 'autocompletion/enter-key', checked)
def toggle_singletab(self, checked):
"""Toggle single tab mode"""
CONF.set(self.ID, 'single_tab', checked)
def closing(self, cancelable=False):
"""Perform actions before parent main window is closed"""
return True
def refresh(self):
"""Refresh tabwidget"""
if self.tabwidget.count():
editor = self.tabwidget.currentWidget().shell
editor.setFocus()
else:
editor = None
self.find_widget.set_editor(editor)
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(unicode(text))
if match:
fname, lnb = match.groups()
self.emit(SIGNAL("edit_goto(QString,int)"),
osp.abspath(fname), int(lnb))
#----Drag and drop
def __is_python_script(self, qstr):
"""Is it a valid Python script?"""
fname = unicode(qstr)
return osp.isfile(fname) and \
( fname.endswith('.py') or fname.endswith('.pyw') )
def dragEnterEvent(self, event):
"""Reimplement Qt method
Inform Qt about the types of data that the widget accepts"""
source = event.mimeData()
if source.hasUrls() or \
( source.hasText() and self.__is_python_script(source.text()) ):
event.acceptProposedAction()
def dropEvent(self, event):
"""Reimplement Qt method
Unpack dropped data and handle it"""
source = event.mimeData()
if source.hasText():
self.start(source.text())
elif source.hasUrls():
files = mimedata2url(source)
for fname in files:
if self.__is_python_script(fname):
self.start(fname)
event.acceptProposedAction()
class HistoryLog(SpyderPluginWidget):
"""
History log widget
"""
CONF_SECTION = 'historylog'
CONFIGWIDGET_CLASS = HistoryConfigPage
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.wrap_action = None
self.editors = []
self.filenames = []
self.icons = []
SpyderPluginWidget.__init__(self, parent)
# Initialize plugin
self.initialize_plugin()
self.set_default_color_scheme()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self, text=_("Options"),
icon=get_icon('tooloptions.png'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
#------ SpyderPluginWidget API ---------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return _('History log')
def get_plugin_icon(self):
"""Return widget icon"""
return get_icon('history.png')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.tabwidget.currentWidget()
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
return True
def refresh_plugin(self):
"""Refresh tabwidget"""
if self.tabwidget.count():
editor = self.tabwidget.currentWidget()
else:
editor = None
self.find_widget.set_editor(editor)
def get_plugin_actions(self):
"""Return a list of actions related to plugin"""
history_action = create_action(self, _("History..."),
None, 'history.png',
_("Set history maximum entries"),
triggered=self.change_history_depth)
font_action = create_action(self, _("&Font..."), None,
'font.png', _("Set shell font style"),
triggered=self.change_font)
self.wrap_action = create_action(self, _("Wrap lines"),
toggled=self.toggle_wrap_mode)
self.wrap_action.setChecked( self.get_option('wrap') )
self.menu_actions = [history_action, font_action, self.wrap_action]
return self.menu_actions
def on_first_registration(self):
"""Action to be performed on first plugin registration"""
self.main.tabify_plugins(self.main.extconsole, self)
def register_plugin(self):
"""Register plugin in Spyder's main window"""
self.connect(self, SIGNAL('focus_changed()'),
self.main.plugin_focus_changed)
self.main.add_dockwidget(self)
# self.main.console.set_historylog(self)
self.connect(self.main.console.shell, SIGNAL("refresh()"),
self.refresh_plugin)
def apply_plugin_settings(self, options):
"""Apply configuration file's plugin settings"""
color_scheme_n = 'color_scheme_name'
color_scheme_o = get_color_scheme(self.get_option(color_scheme_n))
font_n = 'plugin_font'
font_o = self.get_plugin_font()
wrap_n = 'wrap'
wrap_o = self.get_option(wrap_n)
self.wrap_action.setChecked(wrap_o)
for editor in self.editors:
if font_n in options:
scs = color_scheme_o if color_scheme_n in options else None
editor.set_font(font_o, scs)
elif color_scheme_n in options:
editor.set_color_scheme(color_scheme_o)
if wrap_n in options:
editor.toggle_wrap_mode(wrap_o)
#------ Private API --------------------------------------------------------
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
filename = self.filenames.pop(index_from)
editor = self.editors.pop(index_from)
icon = self.icons.pop(index_from)
self.filenames.insert(index_to, filename)
self.editors.insert(index_to, editor)
self.icons.insert(index_to, icon)
#------ Public API ---------------------------------------------------------
def add_history(self, filename):
"""
Add new history tab
Slot for SIGNAL('add_history(QString)') emitted by shell instance
"""
filename = encoding.to_unicode_from_fs(filename)
if filename in self.filenames:
return
editor = codeeditor.CodeEditor(self)
if osp.splitext(filename)[1] == '.py':
language = 'py'
icon = get_icon('python.png')
else:
language = 'bat'
icon = get_icon('cmdprompt.png')
editor.setup_editor(linenumbers=False, language=language,
scrollflagarea=False)
self.connect(editor, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
editor.setReadOnly(True)
color_scheme = get_color_scheme(self.get_option('color_scheme_name'))
editor.set_font( self.get_plugin_font(), color_scheme )
editor.toggle_wrap_mode( self.get_option('wrap') )
text, _ = encoding.read(filename)
editor.set_text(text)
editor.set_cursor_position('eof')
self.editors.append(editor)
self.filenames.append(filename)
self.icons.append(icon)
index = self.tabwidget.addTab(editor, osp.basename(filename))
self.find_widget.set_editor(editor)
self.tabwidget.setTabToolTip(index, filename)
self.tabwidget.setTabIcon(index, icon)
self.tabwidget.setCurrentIndex(index)
def append_to_history(self, filename, command):
"""
Append an entry to history filename
Slot for SIGNAL('append_to_history(QString,QString)')
emitted by shell instance
"""
if not is_text_string(filename): # filename is a QString
filename = to_text_string(filename.toUtf8(), 'utf-8')
command = to_text_string(command)
index = self.filenames.index(filename)
self.editors[index].append(command)
if self.get_option('go_to_eof'):
self.editors[index].set_cursor_position('eof')
self.tabwidget.setCurrentIndex(index)
def change_history_depth(self):
"Change history max entries"""
depth, valid = QInputDialog.getInteger(self, _('History'),
_('Maximum entries'),
self.get_option('max_entries'),
10, 10000)
if valid:
self.set_option('max_entries', depth)
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(self.get_plugin_font(),
self, _("Select a new font"))
if valid:
for editor in self.editors:
editor.set_font(font)
self.set_plugin_font(font)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
if self.tabwidget is None:
return
for editor in self.editors:
editor.toggle_wrap_mode(checked)
self.set_option('wrap', checked)
class ExternalConsole(SpyderPluginWidget):
"""
Console widget
"""
ID = 'external_shell'
def __init__(self, parent, light_mode):
self.light_mode = light_mode
self.commands = []
self.tabwidget = None
self.menu_actions = None
self.inspector = None
self.historylog = None
self.variableexplorer = None # variable explorer plugin
self.ipython_count = 0
self.python_count = 0
self.terminal_count = 0
if CONF.get(self.ID, 'ipython_options', None) is None:
CONF.set(self.ID, 'ipython_options',
self.get_default_ipython_options())
self.shells = []
self.filenames = []
self.icons = []
SpyderPluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.tabwidget.set_close_function(self.close_console)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
filename = self.filenames.pop(index_from)
shell = self.shells.pop(index_from)
icons = self.icons.pop(index_from)
self.filenames.insert(index_to, filename)
self.shells.insert(index_to, shell)
self.icons.insert(index_to, icons)
def close_console(self, index=None):
if not self.tabwidget.count():
return
if index is None:
index = self.tabwidget.currentIndex()
self.tabwidget.widget(index).close()
self.tabwidget.removeTab(index)
self.filenames.pop(index)
self.shells.pop(index)
self.icons.pop(index)
def set_historylog(self, historylog):
"""Bind historylog instance to this console"""
self.historylog = historylog
def set_inspector(self, inspector):
"""Bind inspector instance to this console"""
self.inspector = inspector
inspector.set_external_console(self)
def set_variableexplorer(self, variableexplorer):
"""Set variable explorer plugin"""
self.variableexplorer = variableexplorer
def __find_python_shell(self):
current_index = self.tabwidget.currentIndex()
if current_index == -1:
return
from spyderlib.widgets.externalshell import pythonshell
for index in [current_index]+range(self.tabwidget.count()):
shellwidget = self.tabwidget.widget(index)
if isinstance(shellwidget, pythonshell.ExternalPythonShell):
self.tabwidget.setCurrentIndex(index)
return shellwidget
def get_running_python_shell(self):
"""
Called by object inspector to retrieve a running Python shell instance
"""
current_index = self.tabwidget.currentIndex()
if current_index == -1:
return
from spyderlib.widgets.externalshell import pythonshell
shellwidgets = [self.tabwidget.widget(index)
for index in range(self.tabwidget.count())]
shellwidgets = [_w for _w in shellwidgets
if isinstance(_w, pythonshell.ExternalPythonShell) \
and _w.is_running()]
if shellwidgets:
# First, iterate on interpreters only:
for shellwidget in shellwidgets:
if shellwidget.is_interpreter():
return shellwidget.shell
else:
return shellwidgets[0].shell
def run_script_in_current_shell(self, filename):
"""Run script in current shell, if any"""
shellwidget = self.__find_python_shell()
if shellwidget is not None and shellwidget.is_running():
line = "runfile(r'%s')" % unicode(filename)
shellwidget.shell.execute_lines(line)
shellwidget.shell.setFocus()
def set_current_shell_working_directory(self, directory):
"""Set current shell working directory"""
shellwidget = self.__find_python_shell()
if shellwidget is not None and shellwidget.is_running():
shellwidget.shell.set_cwd(unicode(directory))
def execute_python_code(self, lines):
"""Execute Python code in an already opened Python interpreter"""
shellwidget = self.__find_python_shell()
if shellwidget is not None:
shellwidget.shell.execute_lines(unicode(lines))
shellwidget.shell.setFocus()
def start(self, fname, wdir=None, ask_for_arguments=False,
interact=False, debug=False, python=True,
ipython=False, arguments=None, current=False):
"""Start new console"""
# Note: fname is None <=> Python interpreter
fname = unicode(fname) if isinstance(fname, QString) else fname
wdir = unicode(wdir) if isinstance(wdir, QString) else wdir
if fname is not None and fname in self.filenames:
index = self.filenames.index(fname)
if CONF.get(self.ID, 'single_tab'):
old_shell = self.shells[index]
if old_shell.is_running():
answer = QMessageBox.question(self, self.get_plugin_title(),
self.tr("%1 is already running in a separate process.\n"
"Do you want to kill the process before starting "
"a new one?").arg(osp.basename(fname)),
QMessageBox.Yes | QMessageBox.Cancel)
if answer == QMessageBox.Yes:
old_shell.process.kill()
old_shell.process.waitForFinished()
else:
return
self.close_console(index)
else:
index = 0
# Creating a new external shell
pythonpath = self.main.get_spyder_pythonpath()
if python:
umd_enabled = CONF.get(self.ID, 'umd/enabled')
umd_namelist = CONF.get(self.ID, 'umd/namelist')
umd_verbose = CONF.get(self.ID, 'umd/verbose')
shellwidget = ExternalPythonShell(self, fname, wdir, self.commands,
interact, debug, path=pythonpath, ipython=ipython,
arguments=arguments, stand_alone=self.light_mode,
umd_enabled=umd_enabled, umd_namelist=umd_namelist,
umd_verbose=umd_verbose)
if self.variableexplorer is not None:
self.variableexplorer.add_shellwidget(shellwidget)
else:
shellwidget = ExternalSystemShell(self, wdir, path=pythonpath)
# Code completion / calltips
case_sensitive = CONF.get(self.ID, 'codecompletion/case-sensitivity')
show_single = CONF.get(self.ID, 'codecompletion/select-single')
from_document = CONF.get(self.ID, 'codecompletion/from-document')
shellwidget.shell.setup_code_completion(case_sensitive, show_single,
from_document)
shellwidget.shell.setMaximumBlockCount( CONF.get(self.ID,
'max_line_count') )
shellwidget.shell.set_font( get_font(self.ID) )
shellwidget.shell.toggle_wrap_mode( CONF.get(self.ID, 'wrap') )
shellwidget.shell.set_calltips( CONF.get(self.ID, 'calltips') )
shellwidget.shell.set_codecompletion_auto( CONF.get(self.ID,
'codecompletion/auto') )
shellwidget.shell.set_codecompletion_enter(CONF.get(self.ID,
'codecompletion/enter-key'))
if python and self.inspector is not None:
shellwidget.shell.set_inspector(self.inspector)
if self.historylog is not None:
self.historylog.add_history(shellwidget.shell.history_filename)
self.connect(shellwidget.shell,
SIGNAL('append_to_history(QString,QString)'),
self.historylog.append_to_history)
self.connect(shellwidget.shell, SIGNAL("go_to_error(QString)"),
self.go_to_error)
self.connect(shellwidget.shell, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
if python:
if fname is None:
if ipython:
self.ipython_count += 1
tab_name = "IPython %d" % self.ipython_count
tab_icon1 = get_icon('ipython.png')
tab_icon2 = get_icon('ipython_t.png')
else:
self.python_count += 1
tab_name = "Python %d" % self.python_count
tab_icon1 = get_icon('python.png')
tab_icon2 = get_icon('python_t.png')
else:
tab_name = osp.basename(fname)
tab_icon1 = get_icon('run.png')
tab_icon2 = get_icon('terminated.png')
else:
fname = id(shellwidget)
if os.name == 'nt':
tab_name = self.tr("Command Window")
else:
tab_name = self.tr("Terminal")
self.terminal_count += 1
tab_name += (" %d" % self.terminal_count)
tab_icon1 = get_icon('cmdprompt.png')
tab_icon2 = get_icon('cmdprompt_t.png')
self.shells.insert(index, shellwidget)
self.filenames.insert(index, fname)
self.icons.insert(index, (tab_icon1, tab_icon2))
if index is None:
index = self.tabwidget.addTab(shellwidget, tab_name)
else:
self.tabwidget.insertTab(index, shellwidget, tab_name)
self.connect(shellwidget, SIGNAL("started()"),
lambda sid=id(shellwidget): self.process_started(sid))
self.connect(shellwidget, SIGNAL("finished()"),
lambda sid=id(shellwidget): self.process_finished(sid))
self.find_widget.set_editor(shellwidget.shell)
self.tabwidget.setTabToolTip(index, fname if wdir is None else wdir)
self.tabwidget.setCurrentIndex(index)
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.toggle_icontext(CONF.get(self.ID, 'show_icontext'))
# Start process and give focus to console
shellwidget.start(ask_for_arguments)
shellwidget.shell.setFocus()
#------ Private API --------------------------------------------------------
def process_started(self, shell_id):
for index, shell in enumerate(self.shells):
if id(shell) == shell_id:
icon, _icon = self.icons[index]
self.tabwidget.setTabIcon(index, icon)
if self.inspector is not None:
self.inspector.set_shell(shell.shell)
if self.variableexplorer is not None:
self.variableexplorer.add_shellwidget(shell)
def process_finished(self, shell_id):
for index, shell in enumerate(self.shells):
if id(shell) == shell_id:
_icon, icon = self.icons[index]
self.tabwidget.setTabIcon(index, icon)
if self.inspector is not None:
self.inspector.shell_terminated(shell.shell)
if self.variableexplorer is not None:
self.variableexplorer.remove_shellwidget(shell_id)
#------ SpyderPluginWidget API ---------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return self.tr('Console')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.tabwidget.currentWidget()
def get_plugin_actions(self):
"""Setup actions"""
interpreter_action = create_action(self,
self.tr("Open &interpreter"), None,
'python.png', self.tr("Open a Python interpreter"),
triggered=self.open_interpreter)
if os.name == 'nt':
text = self.tr("Open &command prompt")
tip = self.tr("Open a Windows command prompt")
else:
text = self.tr("Open &terminal")
tip = self.tr("Open a terminal window inside Spyder")
console_action = create_action(self, text, None, 'cmdprompt.png', tip,
triggered=self.open_terminal)
run_action = create_action(self,
self.tr("&Run..."), None,
'run_small.png', self.tr("Run a Python script"),
triggered=self.run_script)
umd_action = create_action(self,
self.tr("Force modules to be completely reloaded"),
tip=self.tr("Force Python to reload modules imported when "
"executing a script in the external console "
"with the 'runfile' function (UMD: User Module "
"Deleter)"),
toggled=self.toggle_umd)
umd_action.setChecked( CONF.get(self.ID, 'umd/enabled') )
python_startup = CONF.get(self.ID, 'open_python_at_startup', None)
ipython_startup = CONF.get(self.ID, 'open_ipython_at_startup', None)
if ipython_startup is None:
ipython_startup = programs.is_module_installed("IPython")
CONF.set(self.ID, 'open_ipython_at_startup', ipython_startup)
if python_startup is None:
python_startup = not ipython_startup
CONF.set(self.ID, 'open_python_at_startup', python_startup)
python_startup_action = create_action(self,
self.tr("Open a Python interpreter at startup"),
toggled=lambda checked:
CONF.set(self.ID, 'open_python_at_startup', checked))
python_startup_action.setChecked(python_startup)
ipython_startup_action = create_action(self,
self.tr("Open a IPython interpreter at startup"),
toggled=lambda checked:
CONF.set(self.ID, 'open_ipython_at_startup', checked))
ipython_startup_action.setChecked(ipython_startup)
buffer_action = create_action(self,
self.tr("Buffer..."), None,
tip=self.tr("Set maximum line count"),
triggered=self.change_max_line_count)
font_action = create_action(self,
self.tr("&Font..."), None,
'font.png', self.tr("Set shell font style"),
triggered=self.change_font)
wrap_action = create_action(self,
self.tr("Wrap lines"),
toggled=self.toggle_wrap_mode)
wrap_action.setChecked( CONF.get(self.ID, 'wrap') )
calltips_action = create_action(self, self.tr("Balloon tips"),
toggled=self.toggle_calltips)
calltips_action.setChecked( CONF.get(self.ID, 'calltips') )
codecompletion_action = create_action(self,
self.tr("Automatic code completion"),
toggled=self.toggle_codecompletion)
codecompletion_action.setChecked( CONF.get(self.ID,
'codecompletion/auto') )
codecompenter_action = create_action(self,
self.tr("Enter key selects completion"),
toggled=self.toggle_codecompletion_enter)
codecompenter_action.setChecked( CONF.get(self.ID,
'codecompletion/enter-key') )
singletab_action = create_action(self,
self.tr("One tab per script"),
toggled=self.toggle_singletab)
singletab_action.setChecked( CONF.get(self.ID, 'single_tab') )
icontext_action = create_action(self, self.tr("Show icons and text"),
toggled=self.toggle_icontext)
icontext_action.setChecked( CONF.get(self.ID, 'show_icontext') )
self.menu_actions = [interpreter_action, console_action, run_action,
umd_action, python_startup_action,
ipython_startup_action, None,
buffer_action, font_action, wrap_action,
calltips_action, codecompletion_action,
codecompenter_action, singletab_action,
icontext_action]
ipython_action = create_action(self,
self.tr("Open IPython interpreter"), None,
'ipython.png',
self.tr("Open an IPython interpreter"),
triggered=self.open_ipython)
ipython_options_action = create_action(self,
self.tr("IPython interpreter options..."), None,
tip=self.tr("Set IPython interpreter "
"command line arguments"),
triggered=self.set_ipython_options)
if programs.is_module_installed("IPython"):
self.menu_actions.insert(3, ipython_options_action)
self.menu_actions.insert(1, ipython_action)
return (self.menu_actions, None)
def open_interpreter_at_startup(self):
"""Open an interpreter at startup, IPython if module is available"""
if CONF.get(self.ID, 'open_ipython_at_startup') \
and programs.is_module_installed("IPython"):
self.open_ipython()
if CONF.get(self.ID, 'open_python_at_startup'):
self.open_interpreter()
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
for shell in self.shells:
shell.process.kill()
return True
def refresh_plugin(self):
"""Refresh tabwidget"""
if self.tabwidget.count():
editor = self.tabwidget.currentWidget().shell
editor.setFocus()
else:
editor = None
self.find_widget.set_editor(editor)
#------ Public API ---------------------------------------------------------
def open_interpreter(self, wdir=None):
"""Open interpreter"""
if wdir is None:
wdir = os.getcwdu()
self.start(fname=None, wdir=unicode(wdir), ask_for_arguments=False,
interact=True, debug=False, python=True)
def get_default_ipython_options(self):
"""Return default ipython command line arguments"""
default_options = []
if programs.is_module_installed('matplotlib'):
default_options.append("-pylab")
else:
default_options.append("-q4thread")
default_options.append("-colors LightBG")
default_options.append("-xmode Plain")
for editor_name in ("scite", "gedit"):
real_name = programs.get_nt_program_name(editor_name)
if programs.is_program_installed(real_name):
default_options.append("-editor "+real_name)
break
return " ".join(default_options)
def open_ipython(self, wdir=None):
"""Open IPython"""
if wdir is None:
wdir = os.getcwdu()
self.start(fname=None, wdir=unicode(wdir), ask_for_arguments=False,
interact=True, debug=False, python=True, ipython=True,
arguments=CONF.get(self.ID, 'ipython_options', ""))
def open_terminal(self, wdir=None):
"""Open terminal"""
if wdir is None:
wdir = os.getcwdu()
self.start(fname=None, wdir=unicode(wdir), ask_for_arguments=False,
interact=True, debug=False, python=False)
def run_script(self):
"""Run a Python script"""
self.emit(SIGNAL('redirect_stdio(bool)'), False)
filename = QFileDialog.getOpenFileName(self,
self.tr("Run Python script"), os.getcwdu(),
self.tr("Python scripts")+" (*.py ; *.pyw)")
self.emit(SIGNAL('redirect_stdio(bool)'), True)
if filename:
self.start(fname=unicode(filename), wdir=None,
ask_for_arguments=False, interact=False, debug=False)
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(get_font(self.ID),
self, self.tr("Select a new font"))
if valid:
for index in range(self.tabwidget.count()):
self.tabwidget.widget(index).shell.set_font(font)
set_font(font, self.ID)
def change_max_line_count(self):
"Change maximum line count"""
mlc, valid = QInputDialog.getInteger(self, self.tr('Buffer'),
self.tr('Maximum line count'),
CONF.get(self.ID, 'max_line_count'),
10, 1000000)
if valid:
for index in range(self.tabwidget.count()):
self.tabwidget.widget(index).shell.setMaximumBlockCount(mlc)
CONF.set(self.ID, 'max_line_count', mlc)
def set_ipython_options(self):
"""Set IPython interpreter arguments"""
arguments, valid = QInputDialog.getText(self,
self.tr('IPython'),
self.tr('IPython command line options:\n'
'(Qt4 support: -q4thread)\n'
'(Qt4 and matplotlib support: -q4thread -pylab)'),
QLineEdit.Normal, CONF.get(self.ID, 'ipython_options'))
if valid:
CONF.set(self.ID, 'ipython_options', unicode(arguments))
def toggle_umd(self, checked):
"""Toggle UMD"""
CONF.set(self.ID, 'umd/enabled', checked)
if checked and self.isVisible():
QMessageBox.warning(self, self.get_plugin_title(),
self.tr("This option will enable the User Module Deleter (UMD) "
"in Python/IPython interpreters. UMD forces Python to "
"reload deeply modules during import when running a "
"Python script using the Spyder's builtin function "
"<b>runfile</b>."
"<br><br><b>1.</b> UMD may require to restart the "
"Python interpreter in which it will be called "
"(otherwise only newly imported modules will be "
"reloaded when executing scripts)."
"<br><br><b>2.</b> If errors occur when re-running a "
"PyQt-based program, please check that the Qt objects "
"are properly destroyed (e.g. you may have to use the "
"attribute <b>Qt.WA_DeleteOnClose</b> on your main "
"window, using the <b>setAttribute</b> method)"),
QMessageBox.Ok)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.toggle_wrap_mode(checked)
CONF.set(self.ID, 'wrap', checked)
def toggle_calltips(self, checked):
"""Toggle calltips"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_calltips(checked)
CONF.set(self.ID, 'calltips', checked)
def toggle_codecompletion(self, checked):
"""Toggle automatic code completion"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_codecompletion_auto(checked)
CONF.set(self.ID, 'codecompletion/auto', checked)
def toggle_codecompletion_enter(self, checked):
"""Toggle Enter key for code completion"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_codecompletion_enter(checked)
CONF.set(self.ID, 'codecompletion/enter-key', checked)
def toggle_singletab(self, checked):
"""Toggle single tab mode"""
CONF.set(self.ID, 'single_tab', checked)
def toggle_icontext(self, checked):
"""Toggle icon text"""
CONF.set(self.ID, 'show_icontext', checked)
if self.tabwidget is None:
return
for index in range(self.tabwidget.count()):
for widget in self.tabwidget.widget(index).get_toolbar_buttons():
if checked:
widget.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
else:
widget.setToolButtonStyle(Qt.ToolButtonIconOnly)
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(unicode(text))
if match:
fname, lnb = match.groups()
self.emit(SIGNAL("edit_goto(QString,int,QString)"),
osp.abspath(fname), int(lnb), '')
#----Drag and drop
def __is_python_script(self, qstr):
"""Is it a valid Python script?"""
fname = unicode(qstr)
return osp.isfile(fname) and \
( fname.endswith('.py') or fname.endswith('.pyw') )
def dragEnterEvent(self, event):
"""Reimplement Qt method
Inform Qt about the types of data that the widget accepts"""
source = event.mimeData()
if source.hasUrls():
if mimedata2url(source):
pathlist = mimedata2url(source)
shellwidget = self.tabwidget.currentWidget()
if all([self.__is_python_script(qstr) for qstr in pathlist]):
event.acceptProposedAction()
elif shellwidget is None or not shellwidget.is_running():
event.ignore()
else:
event.acceptProposedAction()
else:
event.ignore()
elif source.hasText():
event.acceptProposedAction()
def dropEvent(self, event):
"""Reimplement Qt method
Unpack dropped data and handle it"""
source = event.mimeData()
shellwidget = self.tabwidget.currentWidget()
if source.hasText():
qstr = source.text()
if self.__is_python_script(qstr):
self.start(qstr, ask_for_arguments=True)
elif shellwidget:
shellwidget.shell.insert_text(qstr)
elif source.hasUrls():
pathlist = mimedata2url(source)
if all([self.__is_python_script(qstr) for qstr in pathlist]):
for fname in pathlist:
self.start(fname, ask_for_arguments=True)
elif shellwidget:
shellwidget.shell.drop_pathlist(pathlist)
event.acceptProposedAction()
class IPythonConsole(SpyderPluginWidget):
"""
IPython Console plugin
This is a widget with tabs where each one is an IPythonClient
"""
CONF_SECTION = 'ipython_console'
CONFIGWIDGET_CLASS = IPythonConsoleConfigPage
DISABLE_ACTIONS_WHEN_HIDDEN = False
def __init__(self, parent):
SpyderPluginWidget.__init__(self, parent)
self.tabwidget = None
self.menu_actions = None
self.extconsole = None # External console plugin
self.inspector = None # Object inspector plugin
self.historylog = None # History log plugin
self.variableexplorer = None # Variable explorer plugin
self.clients = []
# Initialize plugin
self.initialize_plugin()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
if hasattr(self.tabwidget, 'setDocumentMode')\
and not sys.platform == 'darwin':
# Don't set document mode to true on OSX because it generates
# a crash when the console is detached from the main window
# Fixes Issue 561
self.tabwidget.setDocumentMode(True)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.tabwidget.set_close_function(self.close_client)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
#------ SpyderPluginMixin API ---------------------------------------------
def on_first_registration(self):
"""Action to be performed on first plugin registration"""
self.main.tabify_plugins(self.main.extconsole, self)
def apply_plugin_settings(self, options):
"""Apply configuration file's plugin settings"""
font_n = 'plugin_font'
font_o = self.get_plugin_font()
inspector_n = 'connect_to_oi'
inspector_o = CONF.get('inspector', 'connect/ipython_console')
for client in self.clients:
control = client.get_control()
if font_n in options:
client.set_font(font_o)
if inspector_n in options and control is not None:
control.set_inspector_enabled(inspector_o)
def toggle_view(self, checked):
"""Toggle view"""
if checked:
self.dockwidget.show()
self.dockwidget.raise_()
# Start a client in case there are none shown
if not self.clients:
if self.main.is_setting_up:
self.create_new_client(give_focus=False)
else:
self.create_new_client(give_focus=True)
else:
self.dockwidget.hide()
#------ SpyderPluginWidget API --------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return _('IPython console')
def get_plugin_icon(self):
"""Return widget icon"""
return get_icon('ipython_console.png')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
client = self.tabwidget.currentWidget()
if client is not None:
return client.get_control()
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
for client in self.clients:
client.close()
return True
def refresh_plugin(self):
"""Refresh tabwidget"""
client = None
if self.tabwidget.count():
# Give focus to the control widget of the selected tab
client = self.tabwidget.currentWidget()
control = client.get_control()
control.setFocus()
widgets = client.get_toolbar_buttons() + [5]
# Change extconsole tab to the client's kernel widget
idx = self.extconsole.get_shell_index_from_id(
client.kernel_widget_id)
if idx is not None:
self.extconsole.tabwidget.setCurrentIndex(idx)
else:
control = None
widgets = []
self.find_widget.set_editor(control)
self.tabwidget.set_corner_widgets({Qt.TopRightCorner: widgets})
self.main.last_console_plugin_focus_was_python = False
self.emit(SIGNAL('update_plugin_title()'))
def get_plugin_actions(self):
"""Return a list of actions related to plugin"""
create_client_action = create_action(self,
_("Open an &IPython console"),
None,
'ipython_console.png',
triggered=self.create_new_client)
connect_to_kernel_action = create_action(
self,
_("Connect to an existing kernel"),
None,
None,
_("Open a new IPython console connected to an existing kernel"),
triggered=self.create_client_for_kernel)
# Add the action to the 'Consoles' menu on the main window
main_consoles_menu = self.main.consoles_menu_actions
main_consoles_menu.insert(0, create_client_action)
main_consoles_menu += [None, connect_to_kernel_action]
# Plugin actions
self.menu_actions = [create_client_action, connect_to_kernel_action]
return self.menu_actions
def register_plugin(self):
"""Register plugin in Spyder's main window"""
self.main.add_dockwidget(self)
self.extconsole = self.main.extconsole
self.inspector = self.main.inspector
self.historylog = self.main.historylog
self.variableexplorer = self.main.variableexplorer
self.connect(self, SIGNAL('focus_changed()'),
self.main.plugin_focus_changed)
if self.main.editor is not None:
self.connect(self, SIGNAL("edit_goto(QString,int,QString)"),
self.main.editor.load)
self.connect(
self.main.editor,
SIGNAL(
'run_in_current_ipyclient(QString,QString,QString,bool)'),
self.run_script_in_current_client)
#------ Public API (for clients) ------------------------------------------
def get_clients(self):
"""Return clients list"""
return [cl for cl in self.clients if isinstance(cl, IPythonClient)]
# def get_kernels(self):
# """Return IPython kernel widgets list"""
# return [sw for sw in self.shellwidgets
# if isinstance(sw, IPythonKernel)]
#
def get_focus_client(self):
"""Return current client with focus, if any"""
widget = QApplication.focusWidget()
for client in self.get_clients():
if widget is client or widget is client.get_control():
return client
def get_current_client(self):
"""Return the currently selected client"""
client = self.tabwidget.currentWidget()
if client is not None:
return client
def run_script_in_current_client(self, filename, wdir, args, debug):
"""Run script in current client, if any"""
norm = lambda text: remove_backslashes(to_text_string(text))
client = self.get_current_client()
if client is not None:
# Internal kernels, use runfile
if client.kernel_widget_id is not None:
line = "%s('%s'" % ('debugfile' if debug else 'runfile',
norm(filename))
if args:
line += ", args='%s'" % norm(args)
if wdir:
line += ", wdir='%s'" % norm(wdir)
line += ")"
else: # External kernels, use %run
line = "%run "
if debug:
line += "-d "
line += "\"%s\"" % to_text_string(filename)
if args:
line += " %s" % norm(args)
self.execute_python_code(line)
self.visibility_changed(True)
self.raise_()
else:
#XXX: not sure it can really happen
QMessageBox.warning(
self, _('Warning'),
_("No IPython console is currently available to run <b>%s</b>."
"<br><br>Please open a new one and try again.") %
osp.basename(filename), QMessageBox.Ok)
def execute_python_code(self, lines):
client = self.get_current_client()
if client is not None:
client.shellwidget.execute(to_text_string(lines))
self.activateWindow()
client.get_control().setFocus()
def write_to_stdin(self, line):
client = self.get_current_client()
if client is not None:
client.shellwidget.write_to_stdin(line)
def create_new_client(self, give_focus=True):
"""Create a new client"""
client = IPythonClient(self,
history_filename='history.py',
menu_actions=self.menu_actions)
self.add_tab(client, name=client.get_name())
self.main.extconsole.start_ipykernel(client, give_focus=give_focus)
def register_client(self, client, name, restart=False, give_focus=True):
"""Register new client"""
self.connect_client_to_kernel(client)
client.show_shellwidget(give_focus=give_focus)
client.name = name
# Local vars
shellwidget = client.shellwidget
control = shellwidget._control
page_control = shellwidget._page_control
# Handle kernel interrupts
extconsoles = self.extconsole.shellwidgets
kernel_widget = None
if extconsoles:
if extconsoles[-1].connection_file == client.connection_file:
kernel_widget = extconsoles[-1]
if restart:
shellwidget.custom_interrupt_requested.disconnect()
shellwidget.custom_interrupt_requested.connect(
kernel_widget.keyboard_interrupt)
if kernel_widget is None:
shellwidget.custom_interrupt_requested.connect(
client.interrupt_message)
# If we are restarting the kernel we need to rename
# the client tab and do no more from here on
if restart:
self.rename_client_tab(client)
return
# For tracebacks
self.connect(control, SIGNAL("go_to_error(QString)"), self.go_to_error)
# Handle kernel restarts asked by the user
if kernel_widget is not None:
shellwidget.custom_restart_requested.connect(
lambda cl=client: self.restart_kernel(client))
else:
shellwidget.custom_restart_requested.connect(
client.restart_message)
# Print a message if kernel dies unexpectedly
shellwidget.custom_restart_kernel_died.connect(
lambda t: client.if_kernel_dies(t))
# Connect text widget to our inspector
if kernel_widget is not None and self.inspector is not None:
control.set_inspector(self.inspector)
control.set_inspector_enabled(
CONF.get('inspector', 'connect/ipython_console'))
# Connect to our variable explorer
if kernel_widget is not None and self.variableexplorer is not None:
nsb = self.variableexplorer.currentWidget()
# When the autorefresh button is active, our kernels
# start to consume more and more CPU during time
# Fix Issue 1450
# ----------------
# When autorefresh is off by default we need the next
# line so that kernels don't start to consume CPU
# Fix Issue 1595
nsb.auto_refresh_button.setChecked(True)
nsb.auto_refresh_button.setChecked(False)
nsb.auto_refresh_button.setEnabled(False)
nsb.set_ipyclient(client)
client.set_namespacebrowser(nsb)
# Connect client to our history log
if self.historylog is not None:
self.historylog.add_history(client.history_filename)
self.connect(client, SIGNAL('append_to_history(QString,QString)'),
self.historylog.append_to_history)
# Set font for client
client.set_font(self.get_plugin_font())
# Connect focus signal to client's control widget
self.connect(control, SIGNAL('focus_changed()'),
lambda: self.emit(SIGNAL('focus_changed()')))
# Update the find widget if focus changes between control and
# page_control
self.find_widget.set_editor(control)
if page_control:
self.connect(page_control, SIGNAL('focus_changed()'),
lambda: self.emit(SIGNAL('focus_changed()')))
self.connect(control, SIGNAL('visibility_changed(bool)'),
self.refresh_plugin)
self.connect(page_control, SIGNAL('visibility_changed(bool)'),
self.refresh_plugin)
self.connect(page_control, SIGNAL('show_find_widget()'),
self.find_widget.show)
# Update client name
self.rename_client_tab(client)
def close_client(self, index=None, client=None, force=False):
"""Close client tab from index or widget (or close current tab)"""
if not self.tabwidget.count():
return
if client is not None:
index = self.tabwidget.indexOf(client)
if index is None and client is None:
index = self.tabwidget.currentIndex()
if index is not None:
client = self.tabwidget.widget(index)
# Check if related clients or kernels are opened
# and eventually ask before closing them
if not force and isinstance(client, IPythonClient):
idx = self.extconsole.get_shell_index_from_id(
client.kernel_widget_id)
if idx is not None:
close_all = True
if self.get_option('ask_before_closing'):
ans = QMessageBox.question(
self, self.get_plugin_title(),
_("%s will be closed.\n"
"Do you want to kill the associated kernel "
"and all of its clients?") % client.get_name(),
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
if ans == QMessageBox.Cancel:
return
close_all = ans == QMessageBox.Yes
if close_all:
self.extconsole.close_console(index=idx,
from_ipyclient=True)
self.close_related_clients(client)
client.close()
# Note: client index may have changed after closing related widgets
self.tabwidget.removeTab(self.tabwidget.indexOf(client))
self.clients.remove(client)
self.emit(SIGNAL('update_plugin_title()'))
def get_client_index_from_id(self, client_id):
"""Return client index from id"""
for index, client in enumerate(self.clients):
if id(client) == client_id:
return index
def rename_client_tab(self, client):
"""Add the pid of the kernel process to client tab"""
index = self.get_client_index_from_id(id(client))
self.tabwidget.setTabText(index, client.get_name())
def close_related_clients(self, client):
"""Close all clients related to *client*, except itself"""
for cl in self.clients[:]:
if cl is not client and \
cl.connection_file == client.connection_file:
self.close_client(client=cl)
#------ Public API (for kernels) ------------------------------------------
def kernel_and_frontend_match(self, connection_file):
# Determine kernel version
ci = get_connection_info(connection_file,
unpack=True,
profile='default')
if u('control_port') in ci:
kernel_ver = '>=1.0'
else:
kernel_ver = '<1.0'
# is_module_installed checks if frontend version agrees with the
# kernel one
return programs.is_module_installed('IPython', version=kernel_ver)
def create_kernel_manager_and_client(self,
connection_file=None,
hostname=None,
sshkey=None,
password=None):
"""Create kernel manager and client"""
cf = find_connection_file(connection_file, profile='default')
kernel_manager = QtKernelManager(connection_file=cf, config=None)
if programs.is_module_installed('IPython', '>=1.0'):
kernel_client = kernel_manager.client()
kernel_client.load_connection_file()
if hostname is not None:
try:
newports = tunnel_to_kernel(
dict(ip=kernel_client.ip,
shell_port=kernel_client.shell_port,
iopub_port=kernel_client.iopub_port,
stdin_port=kernel_client.stdin_port,
hb_port=kernel_client.hb_port), hostname, sshkey,
password)
(kernel_client.shell_port, kernel_client.iopub_port,
kernel_client.stdin_port,
kernel_client.hb_port) = newports
except Exception as e:
QMessageBox.critical(
self, _('Connection error'),
_('Could not open ssh tunnel\n') + str(e))
return None, None
kernel_client.start_channels()
# To rely on kernel's heartbeat to know when a kernel has died
kernel_client.hb_channel.unpause()
return kernel_manager, kernel_client
else:
kernel_manager.load_connection_file()
if hostname is not None:
try:
newports = tunnel_to_kernel(
dict(ip=kernel_manager.ip,
shell_port=kernel_manager.shell_port,
iopub_port=kernel_manager.iopub_port,
stdin_port=kernel_manager.stdin_port,
hb_port=kernel_manager.hb_port), hostname, sshkey,
password)
(kernel_manager.shell_port, kernel_manager.iopub_port,
kernel_manager.stdin_port,
kernel_manager.hb_port) = newports
except Exception as e:
QMessageBox.critical(
self, _('Connection error'),
_('Could not open ssh tunnel\n') + str(e))
return None, None
kernel_manager.start_channels()
return kernel_manager, None
def connect_client_to_kernel(self, client):
"""
Connect a client to its kernel
"""
km, kc = self.create_kernel_manager_and_client(client.connection_file,
client.hostname,
client.sshkey,
client.password)
if km is not None:
widget = client.shellwidget
widget.kernel_manager = km
widget.kernel_client = kc
def create_client_for_kernel(self):
"""Create a client connected to an existing kernel"""
(cf, hostname, kf, pw,
ok) = KernelConnectionDialog.get_connection_parameters(self)
if not ok:
return
else:
self._create_client_for_kernel(cf, hostname, kf, pw)
def _create_client_for_kernel(self, cf, hostname, kf, pw):
# Verifying if the connection file exists - in the case of an empty
# file name, the last used connection file is returned.
try:
cf = find_connection_file(cf, profile='default')
except (IOError, UnboundLocalError):
QMessageBox.critical(self, _('IPython'),
_("Unable to connect to IPython <b>%s") % cf)
return
# Base client name:
# remove path and extension, and use the last part when split by '-'
base_client_name = osp.splitext(cf.split('/')[-1])[0].split('-')[-1]
# Generating the client name by appending /A, /B... until it is unique
count = 0
while True:
client_name = base_client_name + '/' + chr(65 + count)
for cl in self.get_clients():
if cl.name == client_name:
break
else:
break
count += 1
# Getting kernel_widget_id from the currently open kernels.
kernel_widget_id = None
for sw in self.extconsole.shellwidgets:
if sw.connection_file == cf.split('/')[-1]:
kernel_widget_id = id(sw)
# Verifying if frontend and kernel have compatible versions
if not self.kernel_and_frontend_match(cf):
QMessageBox.critical(
self, _("Mismatch between kernel and frontend"),
_("Your IPython frontend and kernel versions "
"are <b>incompatible!!</b>"
"<br><br>"
"We're sorry but we can't create an IPython "
"console for you."), QMessageBox.Ok)
return
# Creating the client
client = IPythonClient(self,
history_filename='history.py',
connection_file=cf,
kernel_widget_id=kernel_widget_id,
menu_actions=self.menu_actions,
hostname=hostname,
sshkey=kf,
password=pw)
# Adding the tab
self.add_tab(client, name=client.get_name())
# Connecting kernel and client
self.register_client(client, client_name)
def restart_kernel(self, client):
"""
Create a new kernel and connect it to `client` if the user asks for it
"""
# Took this bit of code (until if result == ) from the IPython project
# (qt/frontend_widget.py - restart_kernel).
# Licensed under the BSD license
message = _('Are you sure you want to restart the kernel?')
buttons = QMessageBox.Yes | QMessageBox.No
result = QMessageBox.question(self, _('Restart kernel?'), message,
buttons)
if result == QMessageBox.Yes:
client.show_restart_animation()
# Close old kernel tab
idx = self.extconsole.get_shell_index_from_id(
client.kernel_widget_id)
self.extconsole.close_console(index=idx, from_ipyclient=True)
# Create a new one and connect it to the client
self.extconsole.start_ipykernel(client)
def get_shellwidget_by_kernelwidget_id(self, kernel_id):
"""Return the IPython widget associated to a kernel widget id"""
for cl in self.clients:
if cl.kernel_widget_id == kernel_id:
return cl.shellwidget
else:
raise ValueError("Unknown kernel widget ID %r" % kernel_id)
#------ Public API (for tabs) ---------------------------------------------
def add_tab(self, widget, name):
"""Add tab"""
self.clients.append(widget)
index = self.tabwidget.addTab(widget, get_icon('ipython_console.png'),
name)
self.tabwidget.setCurrentIndex(index)
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.activateWindow()
widget.get_control().setFocus()
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
client = self.clients.pop(index_from)
self.clients.insert(index_to, client)
self.emit(SIGNAL('update_plugin_title()'))
#------ Public API (for help) ---------------------------------------------
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(to_text_string(text))
if match:
fname, lnb = match.groups()
self.emit(SIGNAL("edit_goto(QString,int,QString)"),
osp.abspath(fname), int(lnb), '')
def show_intro(self):
"""Show intro to IPython help"""
from IPython.core.usage import interactive_usage
self.inspector.show_rich_text(interactive_usage)
def show_guiref(self):
"""Show qtconsole help"""
from IPython.core.usage import gui_reference
self.inspector.show_rich_text(gui_reference, collapse=True)
def show_quickref(self):
"""Show IPython Cheat Sheet"""
from IPython.core.usage import quick_reference
self.inspector.show_plain_text(quick_reference)
class HistoryLog(SpyderPluginWidget):
"""
History log widget
"""
ID = 'historylog'
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.editors = []
self.filenames = []
self.icons = []
SpyderPluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self, text=self.tr("Options"),
icon=get_icon('tooloptions.png'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
#------ SpyderPluginWidget API ---------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return self.tr('History log')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.tabwidget.currentWidget()
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
return True
def refresh_plugin(self):
"""Refresh tabwidget"""
if self.tabwidget.count():
editor = self.tabwidget.currentWidget()
else:
editor = None
self.find_widget.set_editor(editor)
def get_plugin_actions(self):
"""Setup actions"""
history_action = create_action(self, self.tr("History..."),
None, 'history.png',
self.tr("Set history maximum entries"),
triggered=self.change_history_depth)
font_action = create_action(self, self.tr("&Font..."), None,
'font.png', self.tr("Set shell font style"),
triggered=self.change_font)
wrap_action = create_action(self, self.tr("Wrap lines"),
toggled=self.toggle_wrap_mode)
wrap_action.setChecked( CONF.get(self.ID, 'wrap') )
self.menu_actions = [history_action, font_action, wrap_action]
return (self.menu_actions, None)
#------ Private API --------------------------------------------------------
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
filename = self.filenames.pop(index_from)
editor = self.editors.pop(index_from)
icon = self.icons.pop(index_from)
self.filenames.insert(index_to, filename)
self.editors.insert(index_to, editor)
self.icons.insert(index_to, icon)
#------ Public API ---------------------------------------------------------
def add_history(self, filename):
"""
Add new history tab
Slot for SIGNAL('add_history(QString)') emitted by shell instance
"""
filename = encoding.to_unicode(filename)
if filename in self.filenames:
return
editor = CodeEditor(self)
if osp.splitext(filename)[1] == '.py':
language = 'py'
icon = get_icon('python.png')
else:
language = 'bat'
icon = get_icon('cmdprompt.png')
editor.setup_editor(linenumbers=False, language=language,
code_folding=True, scrollflagarea=False)
self.connect(editor, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
editor.setReadOnly(True)
editor.set_font( get_font(self.ID) )
editor.toggle_wrap_mode( CONF.get(self.ID, 'wrap') )
text, _ = encoding.read(filename)
editor.set_text(text)
editor.set_cursor_position('eof')
self.editors.append(editor)
self.filenames.append(filename)
self.icons.append(icon)
index = self.tabwidget.addTab(editor, osp.basename(filename))
self.find_widget.set_editor(editor)
self.tabwidget.setTabToolTip(index, filename)
self.tabwidget.setTabIcon(index, icon)
self.tabwidget.setCurrentIndex(index)
def append_to_history(self, filename, command):
"""
Append an entry to history filename
Slot for SIGNAL('append_to_history(QString,QString)')
emitted by shell instance
"""
filename, command = encoding.to_unicode(filename), unicode(command)
index = self.filenames.index(filename)
self.editors[index].append(command)
self.editors[index].set_cursor_position('eof')
self.tabwidget.setCurrentIndex(index)
def change_history_depth(self):
"Change history max entries"""
depth, valid = QInputDialog.getInteger(self, self.tr('History'),
self.tr('Maximum entries'),
CONF.get(self.ID, 'max_entries'),
10, 10000)
if valid:
CONF.set(self.ID, 'max_entries', depth)
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(get_font(self.ID),
self, self.tr("Select a new font"))
if valid:
for editor in self.editors:
editor.set_font(font)
set_font(font, self.ID)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
if self.tabwidget is None:
return
for editor in self.editors:
editor.toggle_wrap_mode(checked)
CONF.set(self.ID, 'wrap', checked)
class IPythonConsole(SpyderPluginWidget):
"""
IPython Console plugin
This is a widget with tabs where each one is an IPythonClient
"""
CONF_SECTION = 'ipython_console'
CONFIGWIDGET_CLASS = IPythonConsoleConfigPage
DISABLE_ACTIONS_WHEN_HIDDEN = False
def __init__(self, parent):
SpyderPluginWidget.__init__(self, parent)
self.tabwidget = None
self.menu_actions = None
self.extconsole = None # External console plugin
self.inspector = None # Object inspector plugin
self.historylog = None # History log plugin
self.variableexplorer = None # Variable explorer plugin
self.clients = []
# Initialize plugin
self.initialize_plugin()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
if hasattr(self.tabwidget, 'setDocumentMode')\
and not sys.platform == 'darwin':
# Don't set document mode to true on OSX because it generates
# a crash when the console is detached from the main window
# Fixes Issue 561
self.tabwidget.setDocumentMode(True)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.tabwidget.set_close_function(self.close_client)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
#------ SpyderPluginMixin API ---------------------------------------------
def on_first_registration(self):
"""Action to be performed on first plugin registration"""
self.main.tabify_plugins(self.main.extconsole, self)
def apply_plugin_settings(self, options):
"""Apply configuration file's plugin settings"""
font_n = 'plugin_font'
font_o = self.get_plugin_font()
inspector_n = 'connect_to_oi'
inspector_o = CONF.get('inspector', 'connect/ipython_console')
for client in self.clients:
control = client.get_control()
if font_n in options:
client.set_font(font_o)
if inspector_n in options and control is not None:
control.set_inspector_enabled(inspector_o)
def toggle_view(self, checked):
"""Toggle view"""
if checked:
self.dockwidget.show()
self.dockwidget.raise_()
# Start a client in case there are none shown
if not self.clients:
if self.main.is_setting_up:
self.create_new_client(give_focus=False)
else:
self.create_new_client(give_focus=True)
else:
self.dockwidget.hide()
#------ SpyderPluginWidget API --------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return _('IPython console')
def get_plugin_icon(self):
"""Return widget icon"""
return get_icon('ipython_console.png')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
client = self.tabwidget.currentWidget()
if client is not None:
return client.get_control()
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
for client in self.clients:
client.close()
return True
def refresh_plugin(self):
"""Refresh tabwidget"""
client = None
if self.tabwidget.count():
# Give focus to the control widget of the selected tab
client = self.tabwidget.currentWidget()
control = client.get_control()
control.setFocus()
widgets = client.get_toolbar_buttons()+[5]
# Change extconsole tab to the client's kernel widget
idx = self.extconsole.get_shell_index_from_id(
client.kernel_widget_id)
if idx is not None:
self.extconsole.tabwidget.setCurrentIndex(idx)
else:
control = None
widgets = []
self.find_widget.set_editor(control)
self.tabwidget.set_corner_widgets({Qt.TopRightCorner: widgets})
self.main.last_console_plugin_focus_was_python = False
self.emit(SIGNAL('update_plugin_title()'))
def get_plugin_actions(self):
"""Return a list of actions related to plugin"""
create_client_action = create_action(self,
_("Open an &IPython console"),
None, 'ipython_console.png',
triggered=self.create_new_client)
connect_to_kernel_action = create_action(self,
_("Connect to an existing kernel"), None, None,
_("Open a new IPython console connected to an existing kernel"),
triggered=self.create_client_for_kernel)
# Add the action to the 'Consoles' menu on the main window
main_consoles_menu = self.main.consoles_menu_actions
main_consoles_menu.insert(0, create_client_action)
main_consoles_menu += [None, connect_to_kernel_action]
# Plugin actions
self.menu_actions = [create_client_action, connect_to_kernel_action]
return self.menu_actions
def register_plugin(self):
"""Register plugin in Spyder's main window"""
self.main.add_dockwidget(self)
self.extconsole = self.main.extconsole
self.inspector = self.main.inspector
self.historylog = self.main.historylog
self.variableexplorer = self.main.variableexplorer
self.connect(self, SIGNAL('focus_changed()'),
self.main.plugin_focus_changed)
if self.main.editor is not None:
self.connect(self, SIGNAL("edit_goto(QString,int,QString)"),
self.main.editor.load)
self.connect(self.main.editor,
SIGNAL('run_in_current_ipyclient(QString,QString,QString,bool)'),
self.run_script_in_current_client)
#------ Public API (for clients) ------------------------------------------
def get_clients(self):
"""Return clients list"""
return [cl for cl in self.clients if isinstance(cl, IPythonClient)]
# def get_kernels(self):
# """Return IPython kernel widgets list"""
# return [sw for sw in self.shellwidgets
# if isinstance(sw, IPythonKernel)]
#
def get_focus_client(self):
"""Return current client with focus, if any"""
widget = QApplication.focusWidget()
for client in self.get_clients():
if widget is client or widget is client.get_control():
return client
def get_current_client(self):
"""Return the currently selected client"""
client = self.tabwidget.currentWidget()
if client is not None:
return client
def run_script_in_current_client(self, filename, wdir, args, debug):
"""Run script in current client, if any"""
norm = lambda text: remove_backslashes(to_text_string(text))
client = self.get_current_client()
if client is not None:
# Internal kernels, use runfile
if client.kernel_widget_id is not None:
line = "%s('%s'" % ('debugfile' if debug else 'runfile',
norm(filename))
if args:
line += ", args='%s'" % norm(args)
if wdir:
line += ", wdir='%s'" % norm(wdir)
line += ")"
else: # External kernels, use %run
line = "%run "
if debug:
line += "-d "
line += "\"%s\"" % to_text_string(filename)
if args:
line += " %s" % norm(args)
self.execute_python_code(line)
self.visibility_changed(True)
self.raise_()
else:
#XXX: not sure it can really happen
QMessageBox.warning(self, _('Warning'),
_("No IPython console is currently available to run <b>%s</b>."
"<br><br>Please open a new one and try again."
) % osp.basename(filename), QMessageBox.Ok)
def execute_python_code(self, lines):
client = self.get_current_client()
if client is not None:
client.shellwidget.execute(to_text_string(lines))
self.activateWindow()
client.get_control().setFocus()
def write_to_stdin(self, line):
client = self.get_current_client()
if client is not None:
client.shellwidget.write_to_stdin(line)
def create_new_client(self, give_focus=True):
"""Create a new client"""
client = IPythonClient(self, history_filename='history.py',
menu_actions=self.menu_actions)
self.add_tab(client, name=client.get_name())
self.main.extconsole.start_ipykernel(client, give_focus=give_focus)
def register_client(self, client, name, restart=False, give_focus=True):
"""Register new client"""
self.connect_client_to_kernel(client)
client.show_shellwidget(give_focus=give_focus)
client.name = name
# Local vars
shellwidget = client.shellwidget
control = shellwidget._control
page_control = shellwidget._page_control
# Handle kernel interrupts
extconsoles = self.extconsole.shellwidgets
kernel_widget = None
if extconsoles:
if extconsoles[-1].connection_file == client.connection_file:
kernel_widget = extconsoles[-1]
if restart:
shellwidget.custom_interrupt_requested.disconnect()
shellwidget.custom_interrupt_requested.connect(
kernel_widget.keyboard_interrupt)
if kernel_widget is None:
shellwidget.custom_interrupt_requested.connect(
client.interrupt_message)
# If we are restarting the kernel we need to rename
# the client tab and do no more from here on
if restart:
self.rename_client_tab(client)
return
# For tracebacks
self.connect(control, SIGNAL("go_to_error(QString)"), self.go_to_error)
# Handle kernel restarts asked by the user
if kernel_widget is not None:
shellwidget.custom_restart_requested.connect(
lambda cl=client: self.restart_kernel(client))
else:
shellwidget.custom_restart_requested.connect(client.restart_message)
# Print a message if kernel dies unexpectedly
shellwidget.custom_restart_kernel_died.connect(
lambda t: client.if_kernel_dies(t))
# Connect text widget to our inspector
if kernel_widget is not None and self.inspector is not None:
control.set_inspector(self.inspector)
control.set_inspector_enabled(CONF.get('inspector',
'connect/ipython_console'))
# Connect to our variable explorer
if kernel_widget is not None and self.variableexplorer is not None:
nsb = self.variableexplorer.currentWidget()
# When the autorefresh button is active, our kernels
# start to consume more and more CPU during time
# Fix Issue 1450
# ----------------
# When autorefresh is off by default we need the next
# line so that kernels don't start to consume CPU
# Fix Issue 1595
nsb.auto_refresh_button.setChecked(True)
nsb.auto_refresh_button.setChecked(False)
nsb.auto_refresh_button.setEnabled(False)
nsb.set_ipyclient(client)
client.set_namespacebrowser(nsb)
# Connect client to our history log
if self.historylog is not None:
self.historylog.add_history(client.history_filename)
self.connect(client, SIGNAL('append_to_history(QString,QString)'),
self.historylog.append_to_history)
# Set font for client
client.set_font( self.get_plugin_font() )
# Connect focus signal to client's control widget
self.connect(control, SIGNAL('focus_changed()'),
lambda: self.emit(SIGNAL('focus_changed()')))
# Update the find widget if focus changes between control and
# page_control
self.find_widget.set_editor(control)
if page_control:
self.connect(page_control, SIGNAL('focus_changed()'),
lambda: self.emit(SIGNAL('focus_changed()')))
self.connect(control, SIGNAL('visibility_changed(bool)'),
self.refresh_plugin)
self.connect(page_control, SIGNAL('visibility_changed(bool)'),
self.refresh_plugin)
self.connect(page_control, SIGNAL('show_find_widget()'),
self.find_widget.show)
# Update client name
self.rename_client_tab(client)
def close_client(self, index=None, client=None, force=False):
"""Close client tab from index or widget (or close current tab)"""
if not self.tabwidget.count():
return
if client is not None:
index = self.tabwidget.indexOf(client)
if index is None and client is None:
index = self.tabwidget.currentIndex()
if index is not None:
client = self.tabwidget.widget(index)
# Check if related clients or kernels are opened
# and eventually ask before closing them
if not force and isinstance(client, IPythonClient):
idx = self.extconsole.get_shell_index_from_id(
client.kernel_widget_id)
if idx is not None:
close_all = True
if self.get_option('ask_before_closing'):
ans = QMessageBox.question(self, self.get_plugin_title(),
_("%s will be closed.\n"
"Do you want to kill the associated kernel "
"and all of its clients?") % client.get_name(),
QMessageBox.Yes|QMessageBox.No|QMessageBox.Cancel)
if ans == QMessageBox.Cancel:
return
close_all = ans == QMessageBox.Yes
if close_all:
self.extconsole.close_console(index=idx,
from_ipyclient=True)
self.close_related_clients(client)
client.close()
# Note: client index may have changed after closing related widgets
self.tabwidget.removeTab(self.tabwidget.indexOf(client))
self.clients.remove(client)
self.emit(SIGNAL('update_plugin_title()'))
def get_client_index_from_id(self, client_id):
"""Return client index from id"""
for index, client in enumerate(self.clients):
if id(client) == client_id:
return index
def rename_client_tab(self, client):
"""Add the pid of the kernel process to client tab"""
index = self.get_client_index_from_id(id(client))
self.tabwidget.setTabText(index, client.get_name())
def close_related_clients(self, client):
"""Close all clients related to *client*, except itself"""
for cl in self.clients[:]:
if cl is not client and \
cl.connection_file == client.connection_file:
self.close_client(client=cl)
#------ Public API (for kernels) ------------------------------------------
def kernel_and_frontend_match(self, connection_file):
# Determine kernel version
ci = get_connection_info(connection_file, unpack=True,
profile='default')
if u('control_port') in ci:
kernel_ver = '>=1.0'
else:
kernel_ver = '<1.0'
# is_module_installed checks if frontend version agrees with the
# kernel one
return programs.is_module_installed('IPython', version=kernel_ver)
def create_kernel_manager_and_client(self, connection_file=None,
hostname=None, sshkey=None,
password=None):
"""Create kernel manager and client"""
cf = find_connection_file(connection_file, profile='default')
kernel_manager = QtKernelManager(connection_file=cf, config=None)
if programs.is_module_installed('IPython', '>=1.0'):
kernel_client = kernel_manager.client()
kernel_client.load_connection_file()
if hostname is not None:
try:
newports = tunnel_to_kernel(dict(ip=kernel_client.ip,
shell_port=kernel_client.shell_port,
iopub_port=kernel_client.iopub_port,
stdin_port=kernel_client.stdin_port,
hb_port=kernel_client.hb_port),
hostname, sshkey, password)
(kernel_client.shell_port, kernel_client.iopub_port,
kernel_client.stdin_port, kernel_client.hb_port) = newports
except Exception as e:
QMessageBox.critical(self, _('Connection error'),
_('Could not open ssh tunnel\n') + str(e))
return None, None
kernel_client.start_channels()
# To rely on kernel's heartbeat to know when a kernel has died
kernel_client.hb_channel.unpause()
return kernel_manager, kernel_client
else:
kernel_manager.load_connection_file()
if hostname is not None:
try:
newports = tunnel_to_kernel(dict(ip=kernel_manager.ip,
shell_port=kernel_manager.shell_port,
iopub_port=kernel_manager.iopub_port,
stdin_port=kernel_manager.stdin_port,
hb_port=kernel_manager.hb_port),
hostname, sshkey, password)
(kernel_manager.shell_port, kernel_manager.iopub_port,
kernel_manager.stdin_port, kernel_manager.hb_port) = newports
except Exception as e:
QMessageBox.critical(self, _('Connection error'),
_('Could not open ssh tunnel\n') + str(e))
return None, None
kernel_manager.start_channels()
return kernel_manager, None
def connect_client_to_kernel(self, client):
"""
Connect a client to its kernel
"""
km, kc = self.create_kernel_manager_and_client(client.connection_file,
client.hostname,
client.sshkey,
client.password)
if km is not None:
widget = client.shellwidget
widget.kernel_manager = km
widget.kernel_client = kc
def create_client_for_kernel(self):
"""Create a client connected to an existing kernel"""
(cf, hostname,
kf, pw, ok) = KernelConnectionDialog.get_connection_parameters(self)
if not ok:
return
else:
self._create_client_for_kernel(cf, hostname, kf, pw)
def _create_client_for_kernel(self, cf, hostname, kf, pw):
# Verifying if the connection file exists - in the case of an empty
# file name, the last used connection file is returned.
try:
cf = find_connection_file(cf, profile='default')
except (IOError, UnboundLocalError):
QMessageBox.critical(self, _('IPython'),
_("Unable to connect to IPython <b>%s") % cf)
return
# Base client name:
# remove path and extension, and use the last part when split by '-'
base_client_name = osp.splitext(cf.split('/')[-1])[0].split('-')[-1]
# Generating the client name by appending /A, /B... until it is unique
count = 0
while True:
client_name = base_client_name + '/' + chr(65 + count)
for cl in self.get_clients():
if cl.name == client_name:
break
else:
break
count += 1
# Getting kernel_widget_id from the currently open kernels.
kernel_widget_id = None
for sw in self.extconsole.shellwidgets:
if sw.connection_file == cf.split('/')[-1]:
kernel_widget_id = id(sw)
# Verifying if frontend and kernel have compatible versions
if not self.kernel_and_frontend_match(cf):
QMessageBox.critical(self,
_("Mismatch between kernel and frontend"),
_("Your IPython frontend and kernel versions "
"are <b>incompatible!!</b>"
"<br><br>"
"We're sorry but we can't create an IPython "
"console for you."
), QMessageBox.Ok)
return
# Creating the client
client = IPythonClient(self, history_filename='history.py',
connection_file=cf,
kernel_widget_id=kernel_widget_id,
menu_actions=self.menu_actions,
hostname=hostname, sshkey=kf, password=pw)
# Adding the tab
self.add_tab(client, name=client.get_name())
# Connecting kernel and client
self.register_client(client, client_name)
def restart_kernel(self, client):
"""
Create a new kernel and connect it to `client` if the user asks for it
"""
# Took this bit of code (until if result == ) from the IPython project
# (qt/frontend_widget.py - restart_kernel).
# Licensed under the BSD license
message = _('Are you sure you want to restart the kernel?')
buttons = QMessageBox.Yes | QMessageBox.No
result = QMessageBox.question(self, _('Restart kernel?'),
message, buttons)
if result == QMessageBox.Yes:
client.show_restart_animation()
# Close old kernel tab
idx = self.extconsole.get_shell_index_from_id(client.kernel_widget_id)
self.extconsole.close_console(index=idx, from_ipyclient=True)
# Create a new one and connect it to the client
self.extconsole.start_ipykernel(client)
def get_shellwidget_by_kernelwidget_id(self, kernel_id):
"""Return the IPython widget associated to a kernel widget id"""
for cl in self.clients:
if cl.kernel_widget_id == kernel_id:
return cl.shellwidget
else:
raise ValueError("Unknown kernel widget ID %r" % kernel_id)
#------ Public API (for tabs) ---------------------------------------------
def add_tab(self, widget, name):
"""Add tab"""
self.clients.append(widget)
index = self.tabwidget.addTab(widget, get_icon('ipython_console.png'),
name)
self.tabwidget.setCurrentIndex(index)
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.activateWindow()
widget.get_control().setFocus()
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
client = self.clients.pop(index_from)
self.clients.insert(index_to, client)
self.emit(SIGNAL('update_plugin_title()'))
#------ Public API (for help) ---------------------------------------------
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(to_text_string(text))
if match:
fname, lnb = match.groups()
self.emit(SIGNAL("edit_goto(QString,int,QString)"),
osp.abspath(fname), int(lnb), '')
def show_intro(self):
"""Show intro to IPython help"""
from IPython.core.usage import interactive_usage
self.inspector.show_rich_text(interactive_usage)
def show_guiref(self):
"""Show qtconsole help"""
from IPython.core.usage import gui_reference
self.inspector.show_rich_text(gui_reference, collapse=True)
def show_quickref(self):
"""Show IPython Cheat Sheet"""
from IPython.core.usage import quick_reference
self.inspector.show_plain_text(quick_reference)
class IPythonConsole(SpyderPluginWidget):
"""
IPython Console plugin
This is a widget with tabs where each one is an IPythonClient
"""
CONF_SECTION = 'ipython_console'
CONFIGWIDGET_CLASS = IPythonConsoleConfigPage
DISABLE_ACTIONS_WHEN_HIDDEN = False
def __init__(self, parent):
SpyderPluginWidget.__init__(self, parent)
self.tabwidget = None
self.menu_actions = None
self.extconsole = None # External console plugin
self.inspector = None # Object inspector plugin
self.historylog = None # History log plugin
self.variableexplorer = None # Variable explorer plugin
self.clients = []
# Initialize plugin
self.initialize_plugin()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
if hasattr(self.tabwidget, 'setDocumentMode')\
and not sys.platform == 'darwin':
# Don't set document mode to true on OSX because it generates
# a crash when the console is detached from the main window
# Fixes Issue 561
self.tabwidget.setDocumentMode(True)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh_plugin)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.tabwidget.set_close_function(self.close_console)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
#------ SpyderPluginWidget API --------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return _('IPython console')
def get_plugin_icon(self):
"""Return widget icon"""
return get_icon('ipython_console.png')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
client = self.tabwidget.currentWidget()
if client is not None:
return client.get_control()
def get_current_client(self):
"""
Return the currently selected client
"""
client = self.tabwidget.currentWidget()
if client is not None:
return client
def run_script_in_current_client(self, filename, wdir, args, debug):
"""Run script in current client, if any"""
norm = lambda text: remove_backslashes(to_text_string(text))
client = self.get_current_client()
if client is not None:
# Internal kernels, use runfile
if client.kernel_widget_id is not None:
line = "%s('%s'" % ('debugfile' if debug else 'runfile',
norm(filename))
if args:
line += ", args='%s'" % norm(args)
if wdir:
line += ", wdir='%s'" % norm(wdir)
line += ")"
else: # External kernels, use %run
line = "%run "
if debug:
line += "-d "
line += "\"%s\"" % to_text_string(filename)
if args:
line += " %s" % norm(args)
self.execute_python_code(line)
self.visibility_changed(True)
self.raise_()
else:
#XXX: not sure it can really happen
QMessageBox.warning(self, _('Warning'),
_("No IPython console is currently available to run <b>%s</b>."
"<br><br>Please open a new one and try again."
) % osp.basename(filename), QMessageBox.Ok)
def execute_python_code(self, lines):
client = self.get_current_client()
if client is not None:
client.shellwidget.execute(to_text_string(lines))
self.activateWindow()
client.get_control().setFocus()
def write_to_stdin(self, line):
client = self.get_current_client()
if client is not None:
client.shellwidget.write_to_stdin(line)
def create_new_client(self):
"""Create a new client"""
client = IPythonClient(self, history_filename='history.py',
menu_actions=self.menu_actions)
self.add_tab(client, name=client.get_name())
self.main.extconsole.start_ipykernel(client)
def get_plugin_actions(self):
"""Return a list of actions related to plugin"""
create_client_action = create_action(self,
_("Open an &IPython console"),
None, 'ipython_console.png',
triggered=self.create_new_client)
connect_to_kernel_action = create_action(self,
_("Connect to an existing kernel"), None, None,
_("Open a new IPython console connected to an existing kernel"),
triggered=self.create_client_for_kernel)
# Add the action to the 'Consoles' menu on the main window
main_consoles_menu = self.main.consoles_menu_actions
main_consoles_menu.insert(0, create_client_action)
main_consoles_menu += [None, connect_to_kernel_action]
# Plugin actions
self.menu_actions = [create_client_action, connect_to_kernel_action]
return self.menu_actions
def on_first_registration(self):
"""Action to be performed on first plugin registration"""
self.main.tabify_plugins(self.main.extconsole, self)
def register_plugin(self):
"""Register plugin in Spyder's main window"""
self.main.add_dockwidget(self)
self.extconsole = self.main.extconsole
self.inspector = self.main.inspector
self.historylog = self.main.historylog
self.variableexplorer = self.main.variableexplorer
self.connect(self, SIGNAL('focus_changed()'),
self.main.plugin_focus_changed)
if self.main.editor is not None:
self.connect(self, SIGNAL("edit_goto(QString,int,QString)"),
self.main.editor.load)
self.connect(self.main.editor,
SIGNAL('run_in_current_ipyclient(QString,QString,QString,bool)'),
self.run_script_in_current_client)
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
for client in self.clients:
client.close()
return True
def refresh_plugin(self):
"""Refresh tabwidget"""
client = None
if self.tabwidget.count():
# Give focus to the control widget of the selected tab
client = self.tabwidget.currentWidget()
control = client.get_control()
control.setFocus()
widgets = client.get_toolbar_buttons()+[5]
# Change extconsole tab to the client's kernel widget
idx = self.extconsole.get_shell_index_from_id(
client.kernel_widget_id)
if idx is not None:
self.extconsole.tabwidget.setCurrentIndex(idx)
else:
control = None
widgets = []
self.find_widget.set_editor(control)
self.tabwidget.set_corner_widgets({Qt.TopRightCorner: widgets})
self.main.last_console_plugin_focus_was_python = False
self.emit(SIGNAL('update_plugin_title()'))
def apply_plugin_settings(self, options):
"""Apply configuration file's plugin settings"""
font_n = 'plugin_font'
font_o = self.get_plugin_font()
inspector_n = 'connect_to_oi'
inspector_o = CONF.get('inspector', 'connect/ipython_console')
for client in self.clients:
control = client.get_control()
if font_n in options:
client.set_font(font_o)
if inspector_n in options and control is not None:
control.set_inspector_enabled(inspector_o)
def kernel_and_frontend_match(self, connection_file):
# Determine kernel version
ci = get_connection_info(connection_file, unpack=True,
profile='default')
if u('control_port') in ci:
kernel_ver = '>=1.0'
else:
kernel_ver = '<1.0'
# is_module_installed checks if frontend version agrees with the
# kernel one
return programs.is_module_installed('IPython', version=kernel_ver)
def create_kernel_manager_and_client(self, connection_file=None):
"""Create kernel manager and client"""
cf = find_connection_file(connection_file, profile='default')
kernel_manager = QtKernelManager(connection_file=cf, config=None)
if programs.is_module_installed('IPython', '>=1.0'):
kernel_client = kernel_manager.client()
kernel_client.load_connection_file()
kernel_client.start_channels()
# To rely on kernel's heartbeat to know when a kernel has died
kernel_client.hb_channel.unpause()
else:
kernel_client = None
kernel_manager.load_connection_file()
kernel_manager.start_channels()
return kernel_manager, kernel_client
def connect_client_to_kernel(self, client):
"""
Connect a client to its kernel
"""
connection_file = client.connection_file
widget = client.shellwidget
km, kc = self.create_kernel_manager_and_client(connection_file)
widget.kernel_manager = km
widget.kernel_client = kc
#------ Private API -------------------------------------------------------
def _show_rich_help(self, text):
"""Use our Object Inspector to show IPython help texts in rich mode"""
from spyderlib.utils.inspector import sphinxify as spx
context = spx.generate_context(name='', argspec='', note='',
math=False)
html_text = spx.sphinxify(text, context)
inspector = self.inspector
inspector.visibility_changed(True)
inspector.raise_()
inspector.switch_to_rich_text()
inspector.set_rich_text_html(html_text,
QUrl.fromLocalFile(spx.CSS_PATH))
def _show_plain_help(self, text):
"""Use our Object Inspector to show IPython help texts in plain mode"""
inspector = self.inspector
inspector.visibility_changed(True)
inspector.raise_()
inspector.switch_to_plain_text()
inspector.set_plain_text(text, is_code=False)
#------ Public API --------------------------------------------------------
def get_clients(self):
"""Return IPython client widgets list"""
return [cl for cl in self.clients if isinstance(cl, IPythonClient)]
# def get_kernels(self):
# """Return IPython kernel widgets list"""
# return [sw for sw in self.shellwidgets
# if isinstance(sw, IPythonKernel)]
#
def get_focus_client(self):
"""Return current client with focus, if any"""
widget = QApplication.focusWidget()
for client in self.get_clients():
if widget is client or widget is client.get_control():
return client
def create_client_for_kernel(self):
"""Create a client connected to an existing kernel"""
example = _("(for example: kernel-3764.json, or simply 3764)")
while True:
cf, valid = QInputDialog.getText(self, _('IPython'),
_('Provide an IPython kernel connection file:')+\
'\n'+example,
QLineEdit.Normal)
if valid:
cf = str(cf)
match = re.match('(kernel-|^)([a-fA-F0-9-]+)(.json|$)', cf)
if match is not None:
kernel_num = match.groups()[1]
if kernel_num:
cf = 'kernel-%s.json' % kernel_num
break
else:
return
# Generating the client name and setting kernel_widget_id
match = re.match('^kernel-([a-fA-F0-9-]+).json', cf)
count = 0
kernel_widget_id = None
while True:
client_name = match.groups()[0]
if '-' in client_name: # Avoid long names
client_name = client_name.split('-')[0]
client_name = client_name + '/' + chr(65+count)
for cl in self.get_clients():
if cl.name == client_name:
kernel_widget_id = cl.kernel_widget_id
break
else:
break
count += 1
# Trying to get kernel_widget_id from the currently opened kernels if
# the previous procedure fails. This could happen when the first
# client connected to a kernel is closed but the kernel is left open
# and you try to connect new clients to it
if kernel_widget_id is None:
for sw in self.extconsole.shellwidgets:
if sw.connection_file == cf:
kernel_widget_id = id(sw)
# Verifying if the kernel exists
try:
find_connection_file(cf, profile='default')
except (IOError, UnboundLocalError):
QMessageBox.critical(self, _('IPython'),
_("Unable to connect to IPython <b>%s") % cf)
return
# Verifying if frontend and kernel have compatible versions
if not self.kernel_and_frontend_match(cf):
QMessageBox.critical(self,
_("Mismatch between kernel and frontend"),
_("Your IPython frontend and kernel versions "
"are <b>incompatible!!</b>"
"<br><br>"
"We're sorry but we can't create an IPython "
"console for you."
), QMessageBox.Ok)
return
# Creating the client
client = IPythonClient(self, history_filename='history.py',
connection_file=cf,
kernel_widget_id=kernel_widget_id,
menu_actions=self.menu_actions)
self.add_tab(client, name=client.get_name())
self.register_client(client, client_name)
def ipywidget_config(self):
"""Generate a Config instance for IPython widgets using our config
system
This let us create each widget with its own config (as oppossed to
IPythonQtConsoleApp, where all widgets have the same config)
"""
# ---- IPython config ----
try:
profile_path = osp.join(get_ipython_dir(), 'profile_default')
full_ip_cfg = load_pyconfig_files(['ipython_qtconsole_config.py'],
profile_path)
# From the full config we only select the IPythonWidget section
# because the others have no effect here.
ip_cfg = Config({'IPythonWidget': full_ip_cfg.IPythonWidget})
except:
ip_cfg = Config()
# ---- Spyder config ----
spy_cfg = Config()
# Make the pager widget a rich one (i.e a QTextEdit)
spy_cfg.IPythonWidget.kind = 'rich'
# Gui completion widget
gui_comp_o = self.get_option('use_gui_completion')
completions = {True: 'droplist', False: 'ncurses'}
spy_cfg.IPythonWidget.gui_completion = completions[gui_comp_o]
# Pager
pager_o = self.get_option('use_pager')
if pager_o:
spy_cfg.IPythonWidget.paging = 'inside'
else:
spy_cfg.IPythonWidget.paging = 'none'
# Calltips
calltips_o = self.get_option('show_calltips')
spy_cfg.IPythonWidget.enable_calltips = calltips_o
# Buffer size
buffer_size_o = self.get_option('buffer_size')
spy_cfg.IPythonWidget.buffer_size = buffer_size_o
# Prompts
in_prompt_o = self.get_option('in_prompt')
out_prompt_o = self.get_option('out_prompt')
if in_prompt_o:
spy_cfg.IPythonWidget.in_prompt = in_prompt_o
if out_prompt_o:
spy_cfg.IPythonWidget.out_prompt = out_prompt_o
# Merge IPython and Spyder configs. Spyder prefs will have prevalence
# over IPython ones
ip_cfg._merge(spy_cfg)
return ip_cfg
def register_client(self, client, name, restart=False):
"""Register new IPython client"""
self.connect_client_to_kernel(client)
client.show_shellwidget()
client.name = name
# If we are restarting the kernel we just need to rename the client tab
if restart:
self.rename_ipyclient_tab(client)
return
shellwidget = client.shellwidget
control = shellwidget._control
page_control = shellwidget._page_control
# For tracebacks
self.connect(control, SIGNAL("go_to_error(QString)"), self.go_to_error)
# Handle kernel interrupts
extconsoles = self.extconsole.shellwidgets
kernel_widget = None
if extconsoles:
if extconsoles[-1].connection_file == client.connection_file:
kernel_widget = extconsoles[-1]
shellwidget.custom_interrupt_requested.connect(
kernel_widget.keyboard_interrupt)
if kernel_widget is None:
shellwidget.custom_interrupt_requested.connect(
client.interrupt_message)
# Handle kernel restarts asked by the user
if kernel_widget is not None:
shellwidget.custom_restart_requested.connect(
lambda cl=client: self.restart_kernel(client))
else:
shellwidget.custom_restart_requested.connect(client.restart_message)
# Print a message if kernel dies unexpectedly
shellwidget.custom_restart_kernel_died.connect(
lambda t: client.if_kernel_dies(t))
# Connect text widget to our inspector
if kernel_widget is not None and self.inspector is not None:
control.set_inspector(self.inspector)
control.set_inspector_enabled(CONF.get('inspector',
'connect/ipython_console'))
# Connect to our variable explorer
if kernel_widget is not None and self.variableexplorer is not None:
nsb = self.variableexplorer.currentWidget()
# When the autorefresh button is active, our kernels
# start to consume more and more CPU during time
# Fix Issue 1450
# ----------------
# When autorefresh is off by default we need the next
# line so that kernels don't start to consume CPU
# Fix Issue 1595
nsb.auto_refresh_button.setChecked(True)
nsb.auto_refresh_button.setChecked(False)
nsb.auto_refresh_button.setEnabled(False)
nsb.set_ipyclient(client)
client.set_namespacebrowser(nsb)
# Connect client to our history log
if self.historylog is not None:
self.historylog.add_history(client.history_filename)
self.connect(client, SIGNAL('append_to_history(QString,QString)'),
self.historylog.append_to_history)
# Apply settings to newly created client widget:
client.set_font( self.get_plugin_font() )
# Add tab and connect focus signal to client's control widget
self.connect(control, SIGNAL('focus_changed()'),
lambda: self.emit(SIGNAL('focus_changed()')))
# Update the find widget if focus changes between control and
# page_control
self.find_widget.set_editor(control)
if page_control:
self.connect(page_control, SIGNAL('focus_changed()'),
lambda: self.emit(SIGNAL('focus_changed()')))
self.connect(control, SIGNAL('visibility_changed(bool)'),
self.refresh_plugin)
self.connect(page_control, SIGNAL('visibility_changed(bool)'),
self.refresh_plugin)
self.connect(page_control, SIGNAL('show_find_widget()'),
self.find_widget.show)
# Update client name
self.rename_ipyclient_tab(client)
def open_client_at_startup(self):
if self.get_option('open_ipython_at_startup', False):
self.create_new_client()
def close_related_ipyclients(self, client):
"""Close all IPython clients related to *client*, except itself"""
for cl in self.clients[:]:
if cl is not client and \
cl.connection_file == client.connection_file:
self.close_console(client=cl)
def get_shellwidget_by_kernelwidget_id(self, kernel_id):
"""Return the IPython widget associated to a kernel widget id"""
for cl in self.clients:
if cl.kernel_widget_id == kernel_id:
return cl.shellwidget
else:
raise ValueError("Unknown kernel widget ID %r" % kernel_id)
def add_tab(self, widget, name):
"""Add tab"""
self.clients.append(widget)
index = self.tabwidget.addTab(widget, get_icon('ipython_console.png'),
name)
self.tabwidget.setCurrentIndex(index)
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.activateWindow()
widget.get_control().setFocus()
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
client = self.clients.pop(index_from)
self.clients.insert(index_to, client)
self.emit(SIGNAL('update_plugin_title()'))
def close_console(self, index=None, client=None, force=False):
"""Close console tab from index or widget (or close current tab)"""
if not self.tabwidget.count():
return
if client is not None:
index = self.tabwidget.indexOf(client)
if index is None and client is None:
index = self.tabwidget.currentIndex()
if index is not None:
client = self.tabwidget.widget(index)
# Check if related clients or kernels are opened
# and eventually ask before closing them
if not force and isinstance(client, IPythonClient):
idx = self.extconsole.get_shell_index_from_id(
client.kernel_widget_id)
if idx is not None:
close_all = True
if self.get_option('ask_before_closing'):
ans = QMessageBox.question(self, self.get_plugin_title(),
_("%s will be closed.\n"
"Do you want to kill the associated kernel "
"and all of its clients?") % client.get_name(),
QMessageBox.Yes|QMessageBox.No|QMessageBox.Cancel)
if ans == QMessageBox.Cancel:
return
close_all = ans == QMessageBox.Yes
if close_all:
self.extconsole.close_console(index=idx,
from_ipyclient=True)
self.close_related_ipyclients(client)
client.close()
# Note: client index may have changed after closing related widgets
self.tabwidget.removeTab(self.tabwidget.indexOf(client))
self.clients.remove(client)
self.emit(SIGNAL('update_plugin_title()'))
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(to_text_string(text))
if match:
fname, lnb = match.groups()
self.emit(SIGNAL("edit_goto(QString,int,QString)"),
osp.abspath(fname), int(lnb), '')
def show_intro(self):
"""Show intro to IPython help"""
from IPython.core.usage import interactive_usage
self._show_rich_help(interactive_usage)
def show_guiref(self):
"""Show qtconsole help"""
from IPython.core.usage import gui_reference
self._show_rich_help(gui_reference)
def show_quickref(self):
"""Show IPython Cheat Sheet"""
from IPython.core.usage import quick_reference
self._show_plain_help(quick_reference)
def get_client_index_from_id(self, client_id):
"""Return client index from id"""
for index, client in enumerate(self.clients):
if id(client) == client_id:
return index
def rename_ipyclient_tab(self, client):
"""Add the pid of the kernel process to an IPython client tab"""
index = self.get_client_index_from_id(id(client))
self.tabwidget.setTabText(index, client.get_name())
def restart_kernel(self, client):
"""
Create a new kernel and connect it to `client` if the user asks for it
"""
# Took this bit of code (until if result == ) from the IPython project
# (qt/frontend_widget.py - restart_kernel).
# Licensed under the BSD license
message = _('Are you sure you want to restart the kernel?')
buttons = QMessageBox.Yes | QMessageBox.No
result = QMessageBox.question(self, _('Restart kernel?'),
message, buttons)
if result == QMessageBox.Yes:
client.show_restart_animation()
# Close old kernel tab
idx = self.extconsole.get_shell_index_from_id(client.kernel_widget_id)
self.extconsole.close_console(index=idx, from_ipyclient=True)
# Create a new one and connect it to the client
self.main.extconsole.start_ipykernel(client)
class HistoryLog(PluginWidget):
"""
History log widget
"""
ID = 'historylog'
location = Qt.RightDockWidgetArea
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.editors = []
self.filenames = []
self.icons = []
PluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh)
self.connect(self.tabwidget, SIGNAL("close_tab(int)"),
self.tabwidget.removeTab)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self,
text=self.tr("Options"),
icon=get_icon('tooloptions.png'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
filename = self.filenames.pop(index_from)
editor = self.editors.pop(index_from)
icon = self.icons.pop(index_from)
self.filenames.insert(index_to, filename)
self.editors.insert(index_to, editor)
self.icons.insert(index_to, icon)
def add_history(self, filename):
"""
Add new history tab
Slot for SIGNAL('add_history(QString)') emitted by shell instance
"""
filename = encoding.to_unicode(filename)
if filename in self.filenames:
return
editor = QsciEditor(self)
if osp.splitext(filename)[1] == '.py':
language = 'py'
icon = get_icon('python.png')
else:
language = 'bat'
icon = get_icon('cmdprompt.png')
editor.setup_editor(linenumbers=False,
language=language,
code_folding=True)
self.connect(editor, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
editor.setReadOnly(True)
editor.set_font(get_font(self.ID))
editor.toggle_wrap_mode(CONF.get(self.ID, 'wrap'))
text, _ = encoding.read(filename)
editor.set_text(text)
editor.set_cursor_position('eof')
self.editors.append(editor)
self.filenames.append(filename)
self.icons.append(icon)
index = self.tabwidget.addTab(editor, osp.basename(filename))
self.find_widget.set_editor(editor)
self.tabwidget.setTabToolTip(index, filename)
self.tabwidget.setTabIcon(index, icon)
self.tabwidget.setCurrentIndex(index)
def append_to_history(self, filename, command):
"""
Append an entry to history filename
Slot for SIGNAL('append_to_history(QString,QString)')
emitted by shell instance
"""
filename, command = encoding.to_unicode(filename), unicode(command)
index = self.filenames.index(filename)
self.editors[index].append(command)
self.editors[index].set_cursor_position('eof')
self.tabwidget.setCurrentIndex(index)
def get_widget_title(self):
"""Return widget title"""
return self.tr('History log')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.tabwidget.currentWidget()
def set_actions(self):
"""Setup actions"""
history_action = create_action(self,
self.tr("History..."),
None,
'history.png',
self.tr("Set history maximum entries"),
triggered=self.change_history_depth)
font_action = create_action(self,
self.tr("&Font..."),
None,
'font.png',
self.tr("Set shell font style"),
triggered=self.change_font)
wrap_action = create_action(self,
self.tr("Wrap lines"),
toggled=self.toggle_wrap_mode)
wrap_action.setChecked(CONF.get(self.ID, 'wrap'))
self.menu_actions = [history_action, font_action, wrap_action]
return (self.menu_actions, None)
def change_history_depth(self):
"Change history max entries" ""
depth, valid = QInputDialog.getInteger(
self, self.tr('History'), self.tr('Maximum entries'),
CONF.get(self.ID, 'max_entries'), 10, 10000)
if valid:
CONF.set(self.ID, 'max_entries', depth)
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(get_font(self.ID), self,
self.tr("Select a new font"))
if valid:
for editor in self.editors:
editor.set_font(font)
set_font(font, self.ID)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
if self.tabwidget is None:
return
for editor in self.editors:
editor.toggle_wrap_mode(checked)
CONF.set(self.ID, 'wrap', checked)
def closing(self, cancelable=False):
"""Perform actions before parent main window is closed"""
return True
def refresh(self):
"""Refresh tabwidget"""
if self.tabwidget.count():
editor = self.tabwidget.currentWidget()
else:
editor = None
self.find_widget.set_editor(editor)
class ExternalConsole(PluginWidget):
"""
Console widget
"""
ID = 'external_shell'
location = Qt.RightDockWidgetArea
def __init__(self, parent, commands=None):
self.commands = commands
self.tabwidget = None
self.menu_actions = None
self.docviewer = None
self.historylog = None
self.shells = []
self.filenames = []
self.icons = []
PluginWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.connect(self.tabwidget, SIGNAL('currentChanged(int)'),
self.refresh)
self.connect(self.tabwidget, SIGNAL("close_tab(int)"),
self.tabwidget.removeTab)
self.connect(self.tabwidget, SIGNAL('move_data(int,int)'),
self.move_tab)
self.close_button = create_toolbutton(
self.tabwidget,
icon=get_icon("fileclose.png"),
triggered=self.close_console,
tip=self.tr("Close current console"))
self.tabwidget.setCornerWidget(self.close_button)
layout.addWidget(self.tabwidget)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Accepting drops
self.setAcceptDrops(True)
def move_tab(self, index_from, index_to):
"""
Move tab (tabs themselves have already been moved by the tabwidget)
"""
filename = self.filenames.pop(index_from)
shell = self.shells.pop(index_from)
icon = self.icons.pop(index_from)
self.filenames.insert(index_to, filename)
self.shells.insert(index_to, shell)
self.icons.insert(index_to, icon)
def close_console(self, index=None):
if not self.tabwidget.count():
return
if index is None:
index = self.tabwidget.currentIndex()
self.tabwidget.widget(index).close()
self.tabwidget.removeTab(index)
self.filenames.pop(index)
self.shells.pop(index)
self.icons.pop(index)
def set_historylog(self, historylog):
"""Bind historylog instance to this console"""
self.historylog = historylog
def set_docviewer(self, docviewer):
"""Bind docviewer instance to this console"""
self.docviewer = docviewer
def execute_python_code(self, lines):
"""Execute Python code in an already opened Python interpreter"""
from spyderlib.widgets.externalshell.pythonshell import ExtPyQsciShell
def execute(index):
shell = self.tabwidget.widget(index).shell
if isinstance(shell, ExtPyQsciShell):
self.tabwidget.setCurrentIndex(index)
shell.execute_lines(unicode(lines))
shell.setFocus()
return True
# Find the Python shell, starting with current widget:
current_index = self.tabwidget.currentIndex()
if current_index == -1:
# No shell!
return
if not execute(current_index):
for index in self.tabwidget.count():
execute(index)
def start(self,
fname,
wdir=None,
ask_for_arguments=False,
interact=False,
debug=False,
python=True):
"""Start new console"""
# Note: fname is None <=> Python interpreter
fname = unicode(fname) if isinstance(fname, QString) else fname
wdir = unicode(wdir) if isinstance(wdir, QString) else wdir
if fname is not None and fname in self.filenames:
index = self.filenames.index(fname)
if CONF.get(self.ID, 'single_tab'):
old_shell = self.shells[index]
if old_shell.is_running():
answer = QMessageBox.question(
self, self.get_widget_title(),
self.tr(
"%1 is already running in a separate process.\n"
"Do you want to kill the process before starting "
"a new one?").arg(osp.basename(fname)),
QMessageBox.Yes | QMessageBox.Cancel)
if answer == QMessageBox.Yes:
old_shell.process.kill()
old_shell.process.waitForFinished()
else:
return
self.close_console(index)
else:
index = 0
# Creating a new external shell
if python:
shell = ExternalPythonShell(self,
fname,
wdir,
self.commands,
interact,
debug,
path=self.main.path)
else:
shell = ExternalSystemShell(self, wdir)
shell.shell.set_font(get_font(self.ID))
shell.shell.toggle_wrap_mode(CONF.get(self.ID, 'wrap'))
shell.shell.set_calltips(CONF.get(self.ID, 'calltips'))
shell.shell.set_codecompletion(
CONF.get(self.ID, 'autocompletion/enabled'))
shell.shell.set_codecompletion_enter(
CONF.get(self.ID, 'autocompletion/enter-key'))
if python:
shell.shell.set_docviewer(self.docviewer)
self.historylog.add_history(shell.shell.history_filename)
self.connect(shell.shell, SIGNAL('append_to_history(QString,QString)'),
self.historylog.append_to_history)
self.connect(shell.shell, SIGNAL("go_to_error(QString)"),
self.go_to_error)
self.connect(shell.shell, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
if python:
if fname is None:
name = "Python"
icon = get_icon('python.png')
else:
name = osp.basename(fname)
icon = get_icon('run.png')
else:
name = "Command Window"
icon = get_icon('cmdprompt.png')
self.shells.insert(index, shell)
self.filenames.insert(index, fname)
self.icons.insert(index, icon)
if index is None:
index = self.tabwidget.addTab(shell, name)
else:
self.tabwidget.insertTab(index, shell, name)
self.connect(shell,
SIGNAL("started()"),
lambda sid=id(shell): self.process_started(sid))
self.connect(shell,
SIGNAL("finished()"),
lambda sid=id(shell): self.process_finished(sid))
self.find_widget.set_editor(shell.shell)
self.tabwidget.setTabToolTip(index, fname if wdir is None else wdir)
self.tabwidget.setCurrentIndex(index)
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
# Start process and give focus to console
shell.start(ask_for_arguments)
shell.shell.setFocus()
def process_started(self, shell_id):
for index, shell in enumerate(self.shells):
if id(shell) == shell_id:
self.tabwidget.setTabIcon(index, self.icons[index])
def process_finished(self, shell_id):
for index, shell in enumerate(self.shells):
if id(shell) == shell_id:
self.tabwidget.setTabIcon(index, get_icon('terminated.png'))
def get_widget_title(self):
"""Return widget title"""
return self.tr('External console')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.tabwidget.currentWidget()
def set_actions(self):
"""Setup actions"""
interpreter_action = create_action(
self,
self.tr("Open &interpreter"),
None,
'python.png',
self.tr("Open a Python interpreter"),
triggered=self.open_interpreter)
if os.name == 'nt':
text = self.tr("Open &command prompt")
tip = self.tr("Open a Windows command prompt")
else:
text = self.tr("Open &command shell")
tip = self.tr("Open a shell window inside Spyder")
console_action = create_action(self,
text,
None,
'cmdprompt.png',
tip,
triggered=self.open_console)
run_action = create_action(self,
self.tr("&Run..."),
None,
'run_small.png',
self.tr("Run a Python script"),
triggered=self.run_script)
font_action = create_action(self,
self.tr("&Font..."),
None,
'font.png',
self.tr("Set shell font style"),
triggered=self.change_font)
wrap_action = create_action(self,
self.tr("Wrap lines"),
toggled=self.toggle_wrap_mode)
wrap_action.setChecked(CONF.get(self.ID, 'wrap'))
calltips_action = create_action(self,
self.tr("Balloon tips"),
toggled=self.toggle_calltips)
calltips_action.setChecked(CONF.get(self.ID, 'calltips'))
codecompletion_action = create_action(
self,
self.tr("Code completion"),
toggled=self.toggle_codecompletion)
codecompletion_action.setChecked(
CONF.get(self.ID, 'autocompletion/enabled'))
codecompenter_action = create_action(
self,
self.tr("Enter key selects completion"),
toggled=self.toggle_codecompletion_enter)
codecompenter_action.setChecked(
CONF.get(self.ID, 'autocompletion/enter-key'))
singletab_action = create_action(self,
self.tr("One tab per script"),
toggled=self.toggle_singletab)
singletab_action.setChecked(CONF.get(self.ID, 'single_tab'))
self.menu_actions = [
interpreter_action, run_action, None, font_action, wrap_action,
calltips_action, codecompletion_action, codecompenter_action,
singletab_action
]
if console_action:
self.menu_actions.insert(1, console_action)
return (self.menu_actions, None)
def open_interpreter(self):
"""Open interpreter"""
self.start(None, os.getcwdu(), False, True, False)
def open_console(self):
"""Open interpreter"""
self.start(None, os.getcwdu(), False, True, False, python=False)
def run_script(self):
"""Run a Python script"""
self.emit(SIGNAL('redirect_stdio(bool)'), False)
filename = QFileDialog.getOpenFileName(
self, self.tr("Run Python script"), os.getcwdu(),
self.tr("Python scripts") + " (*.py ; *.pyw)")
self.emit(SIGNAL('redirect_stdio(bool)'), True)
if filename:
self.start(unicode(filename), None, False, False, False)
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(get_font(self.ID), self,
self.tr("Select a new font"))
if valid:
for index in range(self.tabwidget.count()):
self.tabwidget.widget(index).shell.set_font(font)
set_font(font, self.ID)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.toggle_wrap_mode(checked)
CONF.set(self.ID, 'wrap', checked)
def toggle_calltips(self, checked):
"""Toggle calltips"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_calltips(checked)
CONF.set(self.ID, 'calltips', checked)
def toggle_codecompletion(self, checked):
"""Toggle code completion"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_codecompletion(checked)
CONF.set(self.ID, 'autocompletion/enabled', checked)
def toggle_codecompletion_enter(self, checked):
"""Toggle Enter key for code completion"""
if self.tabwidget is None:
return
for shell in self.shells:
shell.shell.set_codecompletion_enter(checked)
CONF.set(self.ID, 'autocompletion/enter-key', checked)
def toggle_singletab(self, checked):
"""Toggle single tab mode"""
CONF.set(self.ID, 'single_tab', checked)
def closing(self, cancelable=False):
"""Perform actions before parent main window is closed"""
return True
def refresh(self):
"""Refresh tabwidget"""
if self.tabwidget.count():
editor = self.tabwidget.currentWidget().shell
editor.setFocus()
else:
editor = None
self.find_widget.set_editor(editor)
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(unicode(text))
if match:
fname, lnb = match.groups()
self.emit(SIGNAL("edit_goto(QString,int)"), osp.abspath(fname),
int(lnb))
#----Drag and drop
def __is_python_script(self, qstr):
"""Is it a valid Python script?"""
fname = unicode(qstr)
return osp.isfile(fname) and \
( fname.endswith('.py') or fname.endswith('.pyw') )
def dragEnterEvent(self, event):
"""Reimplement Qt method
Inform Qt about the types of data that the widget accepts"""
source = event.mimeData()
if source.hasUrls() or \
( source.hasText() and self.__is_python_script(source.text()) ):
event.acceptProposedAction()
def dropEvent(self, event):
"""Reimplement Qt method
Unpack dropped data and handle it"""
source = event.mimeData()
if source.hasText():
self.start(source.text())
elif source.hasUrls():
files = mimedata2url(source)
for fname in files:
if self.__is_python_script(fname):
self.start(fname)
event.acceptProposedAction()
