def __init__(self, interpreter=None, message="", log='', parent=None):
"""
:param interpreter : InteractiveInterpreter in which
the code will be executed
:param message: welcome message string
:param parent: specifies the parent widget.
If no parent widget has been specified, it is possible to
exit the interpreter by Ctrl-D.
"""
if interpreter is None:
from openalea.core.service.ipython import interpreter
interpreter = interpreter()
# Set interpreter
self.interpreter = interpreter
self.interpreter.widget = self
# Multiple Stream Redirection
GraphicalStreamRedirection.__init__(self)
# Compatibility with visualea
self.runsource = self.interpreter.run_cell
self.runcode = self.interpreter.runcode
self.loadcode = self.interpreter.loadcode
# Write welcome message
self.write(message)
# Set kernel manager
try:
from IPython.qt.inprocess import QtInProcessKernelManager
except ImportError:
import warnings
message = "You are using a deprecated version of IPython (please update)."
warnings.warn(message)
# DEPRECATED !
from IPython.frontend.qt.inprocess_kernelmanager import QtInProcessKernelManager
km = QtInProcessKernelManager(kernel=self.interpreter)
km.start_channels()
self.interpreter.frontends.append(km)
self.kernel_manager = km
else:
km = QtInProcessKernelManager()
km.kernel = self.interpreter
km.kernel.gui = 'qt4'
kernel_client = km.client()
kernel_client.start_channels()
self.kernel_manager = km
self.kernel_client = kernel_client
def initialize(self):
# Init your plugin
self.misc_s = self.locator.get_service('misc')
explorer_container = self.locator.get_service('explorer')
tree = explorer_container.get_tree_projects()
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
self.ipython_console = RichIPythonWidget()
self.ipython_console.kernel_manager = kernel_manager
self.ipython_console.kernel_client = kernel_client
self.ipython_console.exit_requested.connect(stop)
self.ipython_console.show()
self.misc_s.add_widget(self.ipython_console, IMAGES["console"],
"IPython console")
addp = SIGNAL("addProjectToConsole(QString)")
delp = SIGNAL("removeProjectFromConsole(QString)")
self.connect(tree, addp, self._add_project)
self.connect(tree, delp, self._del_project)
def main():
# Print the ID of the main process
print_process_id()
app = guisupport.get_app_qt4()
# Create an in-process kernel
# >>> print_process_id()
# will print the same process ID as the main process
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel.shell.push({'foo': 43, 'print_process_id': print_process_id})
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
app.exit()
control = RichIPythonWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
control.exit_requested.connect(stop)
control.show()
guisupport.start_event_loop_qt4(app)
def setup_console_widget(self):
# Console
if CONSOLE_TYPE == 'pyqtgraph.console':
self.console_widget = pyqtgraph.console.ConsoleWidget(
namespace={
'app': self,
'pg': pg,
'np': np
},
text="ScopeFoundry Console")
elif CONSOLE_TYPE == 'qtconsole':
# https://github.com/ipython/ipython-in-depth/blob/master/examples/Embedding/inprocess_qtconsole.py
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel.shell.push({'np': np, 'app': self})
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
#self.console_widget = RichIPythonWidget()
self.console_widget = RichJupyterWidget()
self.console_widget.setWindowTitle("ScopeFoundry IPython Console")
self.console_widget.kernel_manager = self.kernel_manager
self.console_widget.kernel_client = self.kernel_client
else:
raise ValueError("CONSOLE_TYPE undefined")
return self.console_widget
def show_ipython_console():
# from https://github.com/ipython/ipython/blob/1.x/examples/inprocess/embedded_qtconsole.py
# this might be able to be a dockable panel at some point in the future.
# it should also only allow one window open at a time - I think it steals stdout at start
# and opening a new window stops output working on the old one!
app = guisupport.get_app_qt4()
# Create an in-process kernel
# >>> print_process_id()
# will print the same process ID as the main process
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
app.exit()
control = RichIPythonWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
control.exit_requested.connect(stop)
control.show()
guisupport.start_event_loop_qt4(app)
def __init__(self, *args, **kw):
super(MantidIPythonWidget, self).__init__(*args, **kw)
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
# Figure out the full path to the mantidplotrc.py file and then %run it
from os import path
mantidplotpath = path.split(
path.dirname(__file__))[0] # It's the directory above this one
mantidplotrc = path.join(mantidplotpath, 'mantidplotrc.py')
shell = kernel.shell
shell.run_line_magic('run', mantidplotrc)
# These 3 lines replace the run_code method of IPython's InteractiveShell class (of which the
# shell variable is a derived instance) with our method defined above. The original method
# is renamed so that we can call it from within the our_run_code method.
f = shell.run_code
shell.run_code = types.MethodType(our_run_code, shell)
shell.ipython_run_code = f
kernel_client = kernel_manager.client()
kernel_client.start_channels()
self.kernel_manager = kernel_manager
self.kernel_client = kernel_client
def __init__(self, main_window): """ desc: Constructor. arguments: main_window: The main window object. """ super(ipython_console, self).__init__(main_window) kernel_manager = QtInProcessKernelManager() kernel_manager.start_kernel() self.kernel = kernel_manager.kernel self.kernel.gui = 'qt4' self.kernel.shell.banner1 = '' kernel_client = kernel_manager.client() kernel_client.start_channels() self.control = RichIPythonWidget() self.control.banner = self.banner() self.control.kernel_manager = kernel_manager self.control.kernel_client = kernel_client self.verticalLayout = QtGui.QVBoxLayout(self) self.verticalLayout.setContentsMargins(0,0,0,0) self.setLayout(self.verticalLayout) self.verticalLayout.addWidget(self.control)
def in_process_console(console_class=RichIPythonWidget, **kwargs):
"""Create a console widget, connected to an in-process Kernel
This only works on IPython v 0.13 and above
Parameters
----------
console_class : The class of the console widget to create
kwargs : Extra variables to put into the namespace
"""
km = QtInProcessKernelManager()
km.start_kernel()
kernel = km.kernel
kernel.gui = 'qt4'
client = km.client()
client.start_channels()
control = console_class()
control.kernel_manager = km
control.kernel_client = client
control.shell = kernel.shell
control.shell.user_ns.update(**kwargs)
return control
def main():
#LETS ALSO DO SOME IPYTHOPN PARRALLEL STUFF
global splicer
app = guisupport.get_app_qt4()
from LZM100 import splicer
# Create an in-process kernel
# >>> print_process_id()
# will print the same process ID as the main process
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel.shell.push({'splicer': splicer})
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
app.exit()
control = RichIPythonWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
control.exit_requested.connect(stop)
control.show()
#app = QtGui.QApplication(sys.argv)
#ex = Example()
b = TaperDesign(Taper())
sys.exit(app.exec_())
def __init__(self, parent=None, getfocus=None):
super(IPythonView, self).__init__(parent)
# Create an in-process kernel
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.shell = self.kernel.shell
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.control = RichIPythonWidget()
self.control.set_default_style(colors='linux')
self.control.kernel_manager = self.kernel_manager
self.control.kernel_client = self.kernel_client
self.control.exit_requested.connect(self.stop)
# Enable Pylab mode.
self.shell.enable_pylab()
self.shell.automagic = True
# Add some variables in the namespace.
self.push(galry=galry)
box = QtGui.QVBoxLayout()
box.addWidget(self.control)
box.setContentsMargins(0, 0, 0, 0)
box.setSpacing(0)
self.setLayout(box)
def __init__(self, **kwarg):
super(RichIPythonWidget, self).__init__()
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel.shell.push(kwarg)
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
def __init__(self, parent=None, config=None):
super(IPythonWidget, self).__init__(config=config, parent=parent)
self.kernel_manager = QtInProcessKernelManager(config=config)
self.kernel_manager.start_kernel()
self.kernel_manager.kernel.gui = 'qt4'
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.shell = self.kernel_manager.kernel.shell
self.user_ns = self.kernel_manager.kernel.shell.user_ns
def _setup_kernel(self):
""" Setup the kernel for the widget.
"""
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipy_widget = self.ipy_widget
ipy_widget.kernel_manager = kernel_manager
ipy_widget.kernel_client = kernel_client
def __init__(self):
RichIPythonWidget.__init__(self)
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel.shell.push({'window': self, 'kernel': self.kernel})
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.kernel_client.execute('%pylab inline')
self.exit_requested.connect(self.exit_requested_func)
def showEvent(self, e):
if not self._initialized:
_logger().info('initializing shell')
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
self.kernel_manager = kernel_manager
self.kernel_client = kernel_client
self._initialized = True
self.apply_preferences()
_logger().info('shell initialized')
super(IPythonConsole, self).showEvent(e)
def __init__(self, *args, **kwargs):
super(ErrorConsoleIPythonWidget, self).__init__(*args, **kwargs)
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_manager.kernel.gui = 'qt'
self.kernel_client = kernel_client = self._kernel_manager.client()
kernel_client.start_channels()
self._append_plain_text("\nsdb (%s) -- Stencil Debugger." % Version().sdb_version())
self._append_plain_text(
"\nThe input and refrence fields, savepoints and serializers have been loaded. "
"\nUse the 'whos' command for more information.")
def __init__(self,customBanner=None,*args,**kwargs):
if customBanner!=None: self.banner=customBanner
super(QIPythonWidget, self).__init__(*args,**kwargs)
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_manager.kernel.gui = 'qt4'
self.kernel_client = kernel_client = self._kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
guisupport.get_app_qt4().exit()
self.exit_requested.connect(stop)
def setup_console_widget(self):
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel.shell.push({'np': np, 'app': self})
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.console_widget = RichJupyterWidget()
self.console_widget.setWindowTitle("py4DSTEM IPython Console")
self.console_widget.kernel_manager = self.kernel_manager
self.console_widget.kernel_client = self.kernel_client
return self.console_widget
def _load_ipython(self):
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_manager.kernel.gui = 'qt4'
kernel_manager.kernel.shell.enable_pylab(gui='inline')
kernel_client = kernel_manager.client()
kernel_client.start_channels()
control = RichIPythonWidget()
self.ipythonDockWidget.setWidget(control)
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
control.exit_requested.connect(kernel_client.stop_channels)
control.exit_requested.connect(kernel_manager.shutdown_kernel)
class IPythonNamespaceUpdater(QtCore.QObject):
shell = kernel_manager.kernel.shell
def eventFilter(self, target, e):
if e.type() == QtCore.QEvent.Enter:
self.shell.push(globals())
return False
control.installEventFilter(IPythonNamespaceUpdater(self))
class Debug(object):
def __init__(self, shell):
self.shell = shell
def __call__(self):
import inspect
frame = inspect.currentframe()
try:
temp = frame.f_back.f_globals
temp.update(frame.f_back.f_locals)
finally:
del frame
self.shell.run_line_magic('reset', '-f -s')
self.shell.push(temp)
# now monkeypatch hexrd.debug to use the qt console:
hexrd.debug = Debug(kernel_manager.kernel.shell)
def __init__(self, partent):
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
QtGui.QWidget.__init__(self)
displayname = QtGui.QLabel('iPython Terminal Widget')
mainlayout = QtGui.QGridLayout(self)
# console=IPythonWidget(self)
console = RichIPythonWidget(self)
console.kernel_manager = kernel_manager
console.kernel_client = kernel_client
console.exit_requested.connect(self.stop)
mainlayout.addWidget(console, 0, 0)
def __init__(self, customBanner=None, *args, **kwargs):
if customBanner != None:
self.banner = customBanner
super(_QIPythonWidget, self).__init__(*args, **kwargs)
# Embed the kernel within the event loop and expose the application
# context
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_manager.kernel.gui = 'qt4'
self.kernel_client = kernel_client = self._kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
guisupport.get_app_qt4().exit()
self.exit_requested.connect(stop)
def initialize(self):
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
app = guisupport.get_app_qt4()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
app.exit()
self.kernel = kernel
self.kernel_manager = kernel_manager
self.kernel_client = kernel_client
self.exit_requested.connect(stop)
def __init__(self,customBanner=None,*args,**kwargs):
print ('importing KernelManager')
from IPython.qt.inprocess import QtInProcessKernelManager
print ('import GuiSupport')
from IPython.lib import guisupport
if customBanner!=None: self.banner=customBanner
print ('initializing')
super(QIPythonWidget, self).__init__(*args,**kwargs)
print ('kernel manager creating')
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
print ('kernel manager starting')
kernel_manager.start_kernel()
kernel_manager.kernel.gui = 'qt4'
self.kernel_client = kernel_client = self._kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
guisupport.get_app_qt4().exit()
self.exit_requested.connect(stop)
def setup_console_widget(self):
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel.shell.push({'np': np, 'app': self})
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
#Avoid setting up multiple consoles
alreadysetup = False
if hasattr(self, 'console_widget'):
if (isinstance(self.console_widget, RichJupyterWidget)):
alreadysetup = True
if not alreadysetup: self.console_widget = RichJupyterWidget()
self.console_widget.setWindowTitle("py4DSTEM IPython Console")
self.console_widget.kernel_manager = self.kernel_manager
self.console_widget.kernel_client = self.kernel_client
return self.console_widget
def createIPythonKernel(self):
"""
Create the IPython Kernel
"""
# Create an in-process kernel
self.kernelManager = QtInProcessKernelManager()
self.kernelManager.start_kernel()
self.kernel = self.kernelManager.kernel
self.kernelClient = self.kernelManager.client()
self.kernelClient.start_channels()
self.kernel.shell.enable_matplotlib(gui='inline')
# Load the necessary packages in the embedded kernel
cell = "import numpy as np, matplotlib.pyplot as plt, qtpulsar as qp"
self.kernel.shell.run_cell(cell, store_history=False)
# Set the in-kernel matplotlib color scheme to black.
self.setMplColorScheme('black') # Outside as well (do we need this?)
self.kernel.shell.run_cell(constants.matplotlib_rc_cell_black,
store_history=False)
def in_process_kernel(**kwargs):
"""Connect to an in-process Kernel
This only works on IPython v 0.13 and above
Parameters
----------
kwargs : Extra variables to put into the namespace
"""
kernel_info = {}
kernel_info['manager'] = QtInProcessKernelManager()
kernel_info['manager'].start_kernel()
kernel = kernel_info['manager'].kernel
kernel.gui = 'qt4'
kernel_info['client'] = kernel_info['manager'].client()
kernel_info['client'].start_channels()
kernel_info['shell'] = kernel.shell
return kernel_info
def __init__(self, customBanner=None, *args, **kwargs):
if customBanner != None: self.banner = customBanner
super(QIPythonWidget, self).__init__(*args, **kwargs)
# Start in process kernel
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_manager.kernel.gui = 'qt4'
self.kernel_client = kernel_client = self._kernel_manager.client()
kernel_client.start_channels()
# Pre import some modules and set some configuration options
self.executeCommand('import numpy as np')
self.executeCommand('import matplotlib.pylab as plt')
self.executeCommand('%matplotlib inline')
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
#guisupport.get_app_qt4().exit()
self.exit_requested.connect(stop)
import sys
from IPython.qt.console.rich_ipython_widget import RichIPythonWidget
from IPython.qt.inprocess import QtInProcessKernelManager
from IPython.lib import guisupport
from PyQt4.QtGui import QApplication
app = QApplication(sys.argv)
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
# here you should exit your application with a suitable call
sys.exit()
widget = RichIPythonWidget()
widget.kernel_manager = kernel_manager
widget.kernel_client = kernel_client
widget.exit_requested.connect(stop)
widget.setWindowTitle("IPython shell")
def run(self, dock=False):
# Checks if a console is open
if self.status is not None:
if (dock and self.status == 'docked') or (not dock and self.status
== 'windowed'):
if self.status == 'windowed':
self.control.raise_()
self.control.activateWindow()
return
elif self.status == 'docked':
# Close current
if self.dock is not None:
self.dock.close()
else:
# Close current
self.control.close()
try:
if QT_VERSION == 4:
from IPython.qt.console.rich_ipython_widget import RichIPythonWidget
else:
from qtconsole.rich_ipython_widget import RichIPythonWidget
from IPython.qt.inprocess import QtInProcessKernelManager
from qgis import core, gui
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt%s' % (QT_VERSION if QT_VERSION != 5 else '')
kernel.shell.push({
'iface': self.iface,
'canvas': self.canvas,
'core': core,
'gui': gui,
'propertize': propertize,
'plugin_instance': self,
#'app': app,
})
if int(self.get_settings('propertize', DEFAULT_PROPERTIZE)):
kernel.shell.ex('propertize(core)')
kernel.shell.ex('propertize(gui)')
# Import in the current namespace
kernel.shell.ex('from PyQt%s.QtCore import *' % QT_VERSION)
kernel.shell.ex('from PyQt%s.QtGui import *' % QT_VERSION)
kernel.shell.ex('from qgis.core import *')
kernel.shell.ex('from qgis.gui import *')
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
# No: this exits QGIS!
#app.exit()
self.status = None
self.control = None
self.dock = None
# or RichIPythonWidget
class myWidget(RichIPythonWidget):
def closeEvent(self, event):
stop()
event.accept()
def resizeEvent(self, event):
super(myWidget, self).resizeEvent(event)
self.console_resize()
event.accept()
def get_columns(self):
try:
font_width = QFontMetrics(self.font).width(' ')
except TypeError:
font_width = 10
return int(self.size().width() / font_width)
def console_resize(self):
self.width = self.get_columns()
class myDock(QDockWidget):
def closeEvent(self, event):
stop()
event.accept()
# IPythonWidget.gui_completion : ‘plain’|’droplist’|’ncurses’
# IPythonWidget.height : Integer
# IPythonWidget.width : Integer
# TODO: settings
# myWidget.width = 160
myWidget.gui_completion = 'plain'
myWidget.paging = 'none'
self.control = myWidget()
self.control.kernel_manager = kernel_manager
self.control.kernel_client = kernel_client
self.control.exit_requested.connect(stop)
if not dock:
self.status = 'windowed'
self.control.show()
else:
self.status = 'docked'
self.dock = myDock()
self.dock.setWidget(self.control)
self.iface.addDockWidget(Qt.BottomDockWidgetArea, self.dock)
# Font size regulation
self.set_font()
self.control._set_font(self.console_font)
def shout():
from IPython.core import usage
self.control._control.clear()
self.control._reading = False
self.control._highlighter.highlighting_on = False
try:
self.control._append_before_prompt_pos = self.control._get_cursor(
).position()
except Exception as ex:
# Can't set attribute .... on mac/win
pass
if int(self.get_settings('show_help', DEFAULT_SHOW_HELP)):
banner = getattr(usage, 'default_banner',
usage.default_gui_banner)
self.control._append_html(
'<small>%s</small>' %
banner.replace('\n', '<br>').strip())
if int(self.get_settings('propertize',
DEFAULT_PROPERTIZE)):
propertize_text = (
"""All returning-something and no-args <code>core</code> and <code>gui</code> <code>Qgs*</code> class members have a <code>p_*</code> equivalent property to ease class introspection with <strong>TAB</strong> completion."""
)
else:
propertize_text = _tr(
"""Propertize has been disabled, you can re-activate it in the pugin's settings."""
)
self.control._append_html(
_tr("""<br><h3>Welcome to QGIS <a href="https://ipython.org/">IPython</a> Console</h3>
You have access to <code>canvas</code>, <code>iface</code>, <code>app</code> (QGIS application) objects and to all <code>qgis</code> and <code>PyQt</code> <code>core</code> and <code>gui</code> modules directly from the shell. %s Don't forget that you have access to all your underlying shell commands too!<br>
<em>Enjoy IPyConsole! Another hack by <a href="http://www.itopen.it">ItOpen</a></em></br>
""") % propertize_text)
def monkey_patch_columnize(control):
"""As the name suggests... dynamic column number: stock
qtconsole doesn't resize its column number on window
resize but sticks to 80"""
from IPython.qt.console.completion_plain import text
old_columnize = text.columnize
def new_columnize(items, separator=' ', displaywidth=80):
displaywidth = control.get_columns()
return old_columnize(items, separator, displaywidth)
text.columnize = new_columnize
monkey_patch_columnize(self.control)
QTimer.singleShot(0, shout)
except ImportError as e:
QMessageBox.information(
self.iface.mainWindow(), _tr(u'Error'),
_tr(u'You need to install <b>IPython 3.1.0</b> or <b>Jupyter 1.0.0</b> (and then restart QGIS) before running this <b>IPyConsole</b> plugin.<br>IPython can be installed with <code>pip install "ipython[all]==3.1.0 qtconsole"</code> or (better) <code>pip install jupyter==1.0.0 qtconsole</code>. More informations about IPython installation on <a href="https://ipython.org/install.html">https://ipython.org/install.html</a>. Windows users might need to run the commands as admin in the OSGEO Command Shell.<br>The exception message is: %s'
) % e)
def setup_console_widget(self, kernel=None):
"""
Create and return console QWidget. If Jupyter / IPython is installed
this widget will be a full-featured IPython console. If Jupyter is unavailable
it will fallback to a pyqtgraph.console.ConsoleWidget.
If the app is started in an Jupyter notebook, the console will be
connected to the notebook's IPython kernel.
the returned console_widget will also be accessible as self.console_widget
In order to see the console widget, remember to insert it into an existing
window or call self.console_widget.show() to create a new window
"""
if CONSOLE_TYPE == 'pyqtgraph.console':
self.console_widget = pyqtgraph.console.ConsoleWidget(
namespace={
'app': self,
'pg': pg,
'np': np
},
text="ScopeFoundry Console")
elif CONSOLE_TYPE == 'qtconsole':
if kernel == None:
try: # try to find an existing kernel
#https://github.com/jupyter/notebook/blob/master/docs/source/examples/Notebook/Connecting%20with%20the%20Qt%20Console.ipynb
import ipykernel as kernel
conn_file = kernel.get_connection_file()
import qtconsole.qtconsoleapp
self.qtconsole_app = qtconsole.qtconsoleapp.JupyterQtConsoleApp(
)
self.console_widget = self.qtconsole_app.new_frontend_connection(
conn_file)
self.console_widget.setWindowTitle(
"ScopeFoundry IPython Console")
except: # make your own new in-process kernel
# https://github.com/ipython/ipython-in-depth/blob/master/examples/Embedding/inprocess_qtconsole.py
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.shell.banner1 += """
ScopeFoundry Console
Variables:
* np: numpy package
* app: the ScopeFoundry App object
"""
self.kernel.gui = 'qt4'
self.kernel.shell.push({'np': np, 'app': self})
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
#self.console_widget = RichIPythonWidget()
self.console_widget = RichJupyterWidget()
self.console_widget.setWindowTitle(
"ScopeFoundry IPython Console")
self.console_widget.kernel_manager = self.kernel_manager
self.console_widget.kernel_client = self.kernel_client
else:
import qtconsole.qtconsoleapp
self.qtconsole_app = qtconsole.qtconsoleapp.JupyterQtConsoleApp(
)
self.console_widget = self.qtconsole_app.new_frontend_connection(
kernel.get_connection_file())
self.console_widget.setWindowTitle(
"ScopeFoundry IPython Console")
else:
raise ValueError("CONSOLE_TYPE undefined")
return self.console_widget