|
|
""" A minimal application using the Qt console-style IPython frontend.
|
|
|
|
|
|
This is not a complete console app, as subprocess will not be able to receive
|
|
|
input, there is no real readline support, among other limitations.
|
|
|
|
|
|
Authors:
|
|
|
|
|
|
* Evan Patterson
|
|
|
* Min RK
|
|
|
* Erik Tollerud
|
|
|
* Fernando Perez
|
|
|
* Bussonnier Matthias
|
|
|
* Thomas Kluyver
|
|
|
|
|
|
"""
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Imports
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
# stdlib imports
|
|
|
import json
|
|
|
import os
|
|
|
import signal
|
|
|
import sys
|
|
|
import uuid
|
|
|
|
|
|
# System library imports
|
|
|
from IPython.external.qt import QtGui
|
|
|
|
|
|
# Local imports
|
|
|
from IPython.config.application import boolean_flag
|
|
|
from IPython.core.application import BaseIPythonApplication
|
|
|
from IPython.core.profiledir import ProfileDir
|
|
|
from IPython.lib.kernel import tunnel_to_kernel, find_connection_file
|
|
|
from IPython.frontend.qt.console.frontend_widget import FrontendWidget
|
|
|
from IPython.frontend.qt.console.ipython_widget import IPythonWidget
|
|
|
from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
|
|
|
from IPython.frontend.qt.console import styles
|
|
|
from IPython.frontend.qt.console.mainwindow import MainWindow
|
|
|
from IPython.frontend.qt.kernelmanager import QtKernelManager
|
|
|
from IPython.utils.path import filefind
|
|
|
from IPython.utils.py3compat import str_to_bytes
|
|
|
from IPython.utils.traitlets import (
|
|
|
Dict, List, Unicode, Int, CaselessStrEnum, CBool, Any
|
|
|
)
|
|
|
from IPython.zmq.ipkernel import (
|
|
|
flags as ipkernel_flags,
|
|
|
aliases as ipkernel_aliases,
|
|
|
IPKernelApp
|
|
|
)
|
|
|
from IPython.zmq.session import Session, default_secure
|
|
|
from IPython.zmq.zmqshell import ZMQInteractiveShell
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Network Constants
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Globals
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
_examples = """
|
|
|
ipython qtconsole # start the qtconsole
|
|
|
ipython qtconsole --pylab=inline # start with pylab in inline plotting mode
|
|
|
"""
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Aliases and Flags
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
flags = dict(ipkernel_flags)
|
|
|
qt_flags = {
|
|
|
'existing' : ({'IPythonQtConsoleApp' : {'existing' : 'kernel*.json'}},
|
|
|
"Connect to an existing kernel. If no argument specified, guess most recent"),
|
|
|
'pure' : ({'IPythonQtConsoleApp' : {'pure' : True}},
|
|
|
"Use a pure Python kernel instead of an IPython kernel."),
|
|
|
'plain' : ({'ConsoleWidget' : {'kind' : 'plain'}},
|
|
|
"Disable rich text support."),
|
|
|
}
|
|
|
qt_flags.update(boolean_flag(
|
|
|
'gui-completion', 'ConsoleWidget.gui_completion',
|
|
|
"use a GUI widget for tab completion",
|
|
|
"use plaintext output for completion"
|
|
|
))
|
|
|
qt_flags.update(boolean_flag(
|
|
|
'confirm-exit', 'IPythonQtConsoleApp.confirm_exit',
|
|
|
"""Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
|
|
|
to force a direct exit without any confirmation.
|
|
|
""",
|
|
|
"""Don't prompt the user when exiting. This will terminate the kernel
|
|
|
if it is owned by the frontend, and leave it alive if it is external.
|
|
|
"""
|
|
|
))
|
|
|
flags.update(qt_flags)
|
|
|
|
|
|
aliases = dict(ipkernel_aliases)
|
|
|
|
|
|
qt_aliases = dict(
|
|
|
hb = 'IPythonQtConsoleApp.hb_port',
|
|
|
shell = 'IPythonQtConsoleApp.shell_port',
|
|
|
iopub = 'IPythonQtConsoleApp.iopub_port',
|
|
|
stdin = 'IPythonQtConsoleApp.stdin_port',
|
|
|
ip = 'IPythonQtConsoleApp.ip',
|
|
|
existing = 'IPythonQtConsoleApp.existing',
|
|
|
f = 'IPythonQtConsoleApp.connection_file',
|
|
|
|
|
|
style = 'IPythonWidget.syntax_style',
|
|
|
stylesheet = 'IPythonQtConsoleApp.stylesheet',
|
|
|
colors = 'ZMQInteractiveShell.colors',
|
|
|
|
|
|
editor = 'IPythonWidget.editor',
|
|
|
paging = 'ConsoleWidget.paging',
|
|
|
ssh = 'IPythonQtConsoleApp.sshserver',
|
|
|
)
|
|
|
aliases.update(qt_aliases)
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Classes
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# IPythonQtConsole
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
class IPythonQtConsoleApp(BaseIPythonApplication):
|
|
|
name = 'ipython-qtconsole'
|
|
|
default_config_file_name='ipython_config.py'
|
|
|
|
|
|
description = """
|
|
|
The IPython QtConsole.
|
|
|
|
|
|
This launches a Console-style application using Qt. It is not a full
|
|
|
console, in that launched terminal subprocesses will not be able to accept
|
|
|
input.
|
|
|
|
|
|
The QtConsole supports various extra features beyond the Terminal IPython
|
|
|
shell, such as inline plotting with matplotlib, via:
|
|
|
|
|
|
ipython qtconsole --pylab=inline
|
|
|
|
|
|
as well as saving your session as HTML, and printing the output.
|
|
|
|
|
|
"""
|
|
|
examples = _examples
|
|
|
|
|
|
classes = [IPKernelApp, IPythonWidget, ZMQInteractiveShell, ProfileDir, Session]
|
|
|
flags = Dict(flags)
|
|
|
aliases = Dict(aliases)
|
|
|
|
|
|
kernel_argv = List(Unicode)
|
|
|
|
|
|
# create requested profiles by default, if they don't exist:
|
|
|
auto_create = CBool(True)
|
|
|
# connection info:
|
|
|
ip = Unicode(LOCALHOST, config=True,
|
|
|
help="""Set the kernel\'s IP address [default localhost].
|
|
|
If the IP address is something other than localhost, then
|
|
|
Consoles on other machines will be able to connect
|
|
|
to the Kernel, so be careful!"""
|
|
|
)
|
|
|
|
|
|
sshserver = Unicode('', config=True,
|
|
|
help="""The SSH server to use to connect to the kernel.""")
|
|
|
sshkey = Unicode('', config=True,
|
|
|
help="""Path to the ssh key to use for logging in to the ssh server.""")
|
|
|
|
|
|
hb_port = Int(0, config=True,
|
|
|
help="set the heartbeat port [default: random]")
|
|
|
shell_port = Int(0, config=True,
|
|
|
help="set the shell (XREP) port [default: random]")
|
|
|
iopub_port = Int(0, config=True,
|
|
|
help="set the iopub (PUB) port [default: random]")
|
|
|
stdin_port = Int(0, config=True,
|
|
|
help="set the stdin (XREQ) port [default: random]")
|
|
|
connection_file = Unicode('', config=True,
|
|
|
help="""JSON file in which to store connection info [default: kernel-<pid>.json]
|
|
|
|
|
|
This file will contain the IP, ports, and authentication key needed to connect
|
|
|
clients to this kernel. By default, this file will be created in the security-dir
|
|
|
of the current profile, but can be specified by absolute path.
|
|
|
""")
|
|
|
def _connection_file_default(self):
|
|
|
return 'kernel-%i.json' % os.getpid()
|
|
|
|
|
|
existing = Unicode('', config=True,
|
|
|
help="""Connect to an already running kernel""")
|
|
|
|
|
|
stylesheet = Unicode('', config=True,
|
|
|
help="path to a custom CSS stylesheet")
|
|
|
|
|
|
pure = CBool(False, config=True,
|
|
|
help="Use a pure Python kernel instead of an IPython kernel.")
|
|
|
plain = CBool(False, config=True,
|
|
|
help="Use a plaintext widget instead of rich text (plain can't print/save).")
|
|
|
|
|
|
def _pure_changed(self, name, old, new):
|
|
|
kind = 'plain' if self.plain else 'rich'
|
|
|
self.config.ConsoleWidget.kind = kind
|
|
|
if self.pure:
|
|
|
self.widget_factory = FrontendWidget
|
|
|
elif self.plain:
|
|
|
self.widget_factory = IPythonWidget
|
|
|
else:
|
|
|
self.widget_factory = RichIPythonWidget
|
|
|
|
|
|
_plain_changed = _pure_changed
|
|
|
|
|
|
confirm_exit = CBool(True, config=True,
|
|
|
help="""
|
|
|
Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
|
|
|
to force a direct exit without any confirmation.""",
|
|
|
)
|
|
|
|
|
|
# the factory for creating a widget
|
|
|
widget_factory = Any(RichIPythonWidget)
|
|
|
|
|
|
def parse_command_line(self, argv=None):
|
|
|
super(IPythonQtConsoleApp, self).parse_command_line(argv)
|
|
|
if argv is None:
|
|
|
argv = sys.argv[1:]
|
|
|
|
|
|
self.kernel_argv = list(argv) # copy
|
|
|
# kernel should inherit default config file from frontend
|
|
|
self.kernel_argv.append("--KernelApp.parent_appname='%s'"%self.name)
|
|
|
# Scrub frontend-specific flags
|
|
|
for a in argv:
|
|
|
if a.startswith('-') and a.lstrip('-') in qt_flags:
|
|
|
self.kernel_argv.remove(a)
|
|
|
swallow_next = False
|
|
|
for a in argv:
|
|
|
if swallow_next:
|
|
|
self.kernel_argv.remove(a)
|
|
|
swallow_next = False
|
|
|
continue
|
|
|
if a.startswith('-'):
|
|
|
split = a.lstrip('-').split('=')
|
|
|
alias = split[0]
|
|
|
if alias in qt_aliases:
|
|
|
self.kernel_argv.remove(a)
|
|
|
if len(split) == 1:
|
|
|
# alias passed with arg via space
|
|
|
swallow_next = True
|
|
|
|
|
|
def init_connection_file(self):
|
|
|
"""find the connection file, and load the info if found.
|
|
|
|
|
|
The current working directory and the current profile's security
|
|
|
directory will be searched for the file if it is not given by
|
|
|
absolute path.
|
|
|
|
|
|
When attempting to connect to an existing kernel and the `--existing`
|
|
|
argument does not match an existing file, it will be interpreted as a
|
|
|
fileglob, and the matching file in the current profile's security dir
|
|
|
with the latest access time will be used.
|
|
|
"""
|
|
|
if self.existing:
|
|
|
try:
|
|
|
cf = find_connection_file(self.existing)
|
|
|
except Exception:
|
|
|
self.log.critical("Could not find existing kernel connection file %s", self.existing)
|
|
|
self.exit(1)
|
|
|
self.log.info("Connecting to existing kernel: %s" % cf)
|
|
|
self.connection_file = cf
|
|
|
# should load_connection_file only be used for existing?
|
|
|
# as it is now, this allows reusing ports if an existing
|
|
|
# file is requested
|
|
|
try:
|
|
|
self.load_connection_file()
|
|
|
except Exception:
|
|
|
self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
|
|
|
self.exit(1)
|
|
|
|
|
|
def load_connection_file(self):
|
|
|
"""load ip/port/hmac config from JSON connection file"""
|
|
|
# this is identical to KernelApp.load_connection_file
|
|
|
# perhaps it can be centralized somewhere?
|
|
|
try:
|
|
|
fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
|
|
|
except IOError:
|
|
|
self.log.debug("Connection File not found: %s", self.connection_file)
|
|
|
return
|
|
|
self.log.debug(u"Loading connection file %s", fname)
|
|
|
with open(fname) as f:
|
|
|
s = f.read()
|
|
|
cfg = json.loads(s)
|
|
|
if self.ip == LOCALHOST and 'ip' in cfg:
|
|
|
# not overridden by config or cl_args
|
|
|
self.ip = cfg['ip']
|
|
|
for channel in ('hb', 'shell', 'iopub', 'stdin'):
|
|
|
name = channel + '_port'
|
|
|
if getattr(self, name) == 0 and name in cfg:
|
|
|
# not overridden by config or cl_args
|
|
|
setattr(self, name, cfg[name])
|
|
|
if 'key' in cfg:
|
|
|
self.config.Session.key = str_to_bytes(cfg['key'])
|
|
|
|
|
|
def init_ssh(self):
|
|
|
"""set up ssh tunnels, if needed."""
|
|
|
if not self.sshserver and not self.sshkey:
|
|
|
return
|
|
|
|
|
|
if self.sshkey and not self.sshserver:
|
|
|
# specifying just the key implies that we are connecting directly
|
|
|
self.sshserver = self.ip
|
|
|
self.ip = LOCALHOST
|
|
|
|
|
|
# build connection dict for tunnels:
|
|
|
info = dict(ip=self.ip,
|
|
|
shell_port=self.shell_port,
|
|
|
iopub_port=self.iopub_port,
|
|
|
stdin_port=self.stdin_port,
|
|
|
hb_port=self.hb_port
|
|
|
)
|
|
|
|
|
|
self.log.info("Forwarding connections to %s via %s"%(self.ip, self.sshserver))
|
|
|
|
|
|
# tunnels return a new set of ports, which will be on localhost:
|
|
|
self.ip = LOCALHOST
|
|
|
try:
|
|
|
newports = tunnel_to_kernel(info, self.sshserver, self.sshkey)
|
|
|
except:
|
|
|
# even catch KeyboardInterrupt
|
|
|
self.log.error("Could not setup tunnels", exc_info=True)
|
|
|
self.exit(1)
|
|
|
|
|
|
self.shell_port, self.iopub_port, self.stdin_port, self.hb_port = newports
|
|
|
|
|
|
cf = self.connection_file
|
|
|
base,ext = os.path.splitext(cf)
|
|
|
base = os.path.basename(base)
|
|
|
self.connection_file = os.path.basename(base)+'-ssh'+ext
|
|
|
self.log.critical("To connect another client via this tunnel, use:")
|
|
|
self.log.critical("--existing %s" % self.connection_file)
|
|
|
|
|
|
def _new_connection_file(self):
|
|
|
return os.path.join(self.profile_dir.security_dir, 'kernel-%s.json' % uuid.uuid4())
|
|
|
|
|
|
def init_kernel_manager(self):
|
|
|
# Don't let Qt or ZMQ swallow KeyboardInterupts.
|
|
|
signal.signal(signal.SIGINT, signal.SIG_DFL)
|
|
|
sec = self.profile_dir.security_dir
|
|
|
try:
|
|
|
cf = filefind(self.connection_file, ['.', sec])
|
|
|
except IOError:
|
|
|
# file might not exist
|
|
|
if self.connection_file == os.path.basename(self.connection_file):
|
|
|
# just shortname, put it in security dir
|
|
|
cf = os.path.join(sec, self.connection_file)
|
|
|
else:
|
|
|
cf = self.connection_file
|
|
|
|
|
|
# Create a KernelManager and start a kernel.
|
|
|
self.kernel_manager = QtKernelManager(
|
|
|
ip=self.ip,
|
|
|
shell_port=self.shell_port,
|
|
|
iopub_port=self.iopub_port,
|
|
|
stdin_port=self.stdin_port,
|
|
|
hb_port=self.hb_port,
|
|
|
connection_file=cf,
|
|
|
config=self.config,
|
|
|
)
|
|
|
# start the kernel
|
|
|
if not self.existing:
|
|
|
kwargs = dict(ipython=not self.pure)
|
|
|
kwargs['extra_arguments'] = self.kernel_argv
|
|
|
self.kernel_manager.start_kernel(**kwargs)
|
|
|
elif self.sshserver:
|
|
|
# ssh, write new connection file
|
|
|
self.kernel_manager.write_connection_file()
|
|
|
self.kernel_manager.start_channels()
|
|
|
|
|
|
def new_frontend_master(self):
|
|
|
""" Create and return new frontend attached to new kernel, launched on localhost.
|
|
|
"""
|
|
|
ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST
|
|
|
kernel_manager = QtKernelManager(
|
|
|
ip=ip,
|
|
|
connection_file=self._new_connection_file(),
|
|
|
config=self.config,
|
|
|
)
|
|
|
# start the kernel
|
|
|
kwargs = dict(ipython=not self.pure)
|
|
|
kwargs['extra_arguments'] = self.kernel_argv
|
|
|
kernel_manager.start_kernel(**kwargs)
|
|
|
kernel_manager.start_channels()
|
|
|
widget = self.widget_factory(config=self.config,
|
|
|
local_kernel=True)
|
|
|
widget.kernel_manager = kernel_manager
|
|
|
widget._existing = False
|
|
|
widget._may_close = True
|
|
|
widget._confirm_exit = self.confirm_exit
|
|
|
return widget
|
|
|
|
|
|
def new_frontend_slave(self, current_widget):
|
|
|
"""Create and return a new frontend attached to an existing kernel.
|
|
|
|
|
|
Parameters
|
|
|
----------
|
|
|
current_widget : IPythonWidget
|
|
|
The IPythonWidget whose kernel this frontend is to share
|
|
|
"""
|
|
|
kernel_manager = QtKernelManager(
|
|
|
connection_file=current_widget.kernel_manager.connection_file,
|
|
|
config = self.config,
|
|
|
)
|
|
|
kernel_manager.load_connection_file()
|
|
|
kernel_manager.start_channels()
|
|
|
widget = self.widget_factory(config=self.config,
|
|
|
local_kernel=False)
|
|
|
widget._existing = True
|
|
|
widget._may_close = False
|
|
|
widget._confirm_exit = False
|
|
|
widget.kernel_manager = kernel_manager
|
|
|
return widget
|
|
|
|
|
|
def init_qt_elements(self):
|
|
|
# Create the widget.
|
|
|
self.app = QtGui.QApplication([])
|
|
|
|
|
|
base_path = os.path.abspath(os.path.dirname(__file__))
|
|
|
icon_path = os.path.join(base_path, 'resources', 'icon', 'IPythonConsole.svg')
|
|
|
self.app.icon = QtGui.QIcon(icon_path)
|
|
|
QtGui.QApplication.setWindowIcon(self.app.icon)
|
|
|
|
|
|
local_kernel = (not self.existing) or self.ip in LOCAL_IPS
|
|
|
self.widget = self.widget_factory(config=self.config,
|
|
|
local_kernel=local_kernel)
|
|
|
self.widget._existing = self.existing
|
|
|
self.widget._may_close = not self.existing
|
|
|
self.widget._confirm_exit = self.confirm_exit
|
|
|
|
|
|
self.widget.kernel_manager = self.kernel_manager
|
|
|
self.window = MainWindow(self.app,
|
|
|
confirm_exit=self.confirm_exit,
|
|
|
new_frontend_factory=self.new_frontend_master,
|
|
|
slave_frontend_factory=self.new_frontend_slave,
|
|
|
)
|
|
|
self.window.log = self.log
|
|
|
self.window.add_tab_with_frontend(self.widget)
|
|
|
self.window.init_menu_bar()
|
|
|
self.window.setWindowTitle('Python' if self.pure else 'IPython')
|
|
|
|
|
|
def init_colors(self):
|
|
|
"""Configure the coloring of the widget"""
|
|
|
# Note: This will be dramatically simplified when colors
|
|
|
# are removed from the backend.
|
|
|
|
|
|
if self.pure:
|
|
|
# only IPythonWidget supports styling
|
|
|
return
|
|
|
|
|
|
# parse the colors arg down to current known labels
|
|
|
try:
|
|
|
colors = self.config.ZMQInteractiveShell.colors
|
|
|
except AttributeError:
|
|
|
colors = None
|
|
|
try:
|
|
|
style = self.config.IPythonWidget.colors
|
|
|
except AttributeError:
|
|
|
style = None
|
|
|
|
|
|
# find the value for colors:
|
|
|
if colors:
|
|
|
colors=colors.lower()
|
|
|
if colors in ('lightbg', 'light'):
|
|
|
colors='lightbg'
|
|
|
elif colors in ('dark', 'linux'):
|
|
|
colors='linux'
|
|
|
else:
|
|
|
colors='nocolor'
|
|
|
elif style:
|
|
|
if style=='bw':
|
|
|
colors='nocolor'
|
|
|
elif styles.dark_style(style):
|
|
|
colors='linux'
|
|
|
else:
|
|
|
colors='lightbg'
|
|
|
else:
|
|
|
colors=None
|
|
|
|
|
|
# Configure the style.
|
|
|
widget = self.widget
|
|
|
if style:
|
|
|
widget.style_sheet = styles.sheet_from_template(style, colors)
|
|
|
widget.syntax_style = style
|
|
|
widget._syntax_style_changed()
|
|
|
widget._style_sheet_changed()
|
|
|
elif colors:
|
|
|
# use a default style
|
|
|
widget.set_default_style(colors=colors)
|
|
|
else:
|
|
|
# this is redundant for now, but allows the widget's
|
|
|
# defaults to change
|
|
|
widget.set_default_style()
|
|
|
|
|
|
if self.stylesheet:
|
|
|
# we got an expicit stylesheet
|
|
|
if os.path.isfile(self.stylesheet):
|
|
|
with open(self.stylesheet) as f:
|
|
|
sheet = f.read()
|
|
|
widget.style_sheet = sheet
|
|
|
widget._style_sheet_changed()
|
|
|
else:
|
|
|
raise IOError("Stylesheet %r not found."%self.stylesheet)
|
|
|
|
|
|
def initialize(self, argv=None):
|
|
|
super(IPythonQtConsoleApp, self).initialize(argv)
|
|
|
self.init_connection_file()
|
|
|
default_secure(self.config)
|
|
|
self.init_ssh()
|
|
|
self.init_kernel_manager()
|
|
|
self.init_qt_elements()
|
|
|
self.init_colors()
|
|
|
|
|
|
def start(self):
|
|
|
|
|
|
# draw the window
|
|
|
self.window.show()
|
|
|
|
|
|
# Start the application main loop.
|
|
|
self.app.exec_()
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Main entry point
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
def main():
|
|
|
app = IPythonQtConsoleApp()
|
|
|
app.initialize()
|
|
|
app.start()
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
main()
|
|
|
|