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 __init__(self):
QMainWindow.__init__(self)
self.hsplit = QSplitter()
self.setCentralWidget(self.hsplit)
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
self.kernel = kernel_manager.kernel
self.kernel.gui = 'qt'
self.control = RichIPythonWidget(gui_completion="droplist")
self.kernel.shell.push({'snipdom': self})
kernel_client = kernel_manager.client()
kernel_client.start_channels()
self.control.kernel_manager = kernel_manager
self.control.kernel_client = kernel_client
self.vsplit = QSplitter()
self.vsplit.setOrientation(Qt.Vertical)
self.vsplit.addWidget(self.control)
self.hsplit.addWidget(self.vsplit)
self.sendButton = QPushButton("send")
#self.sendButton.clicked.connect(self.sendcode)
self.vsplit.addWidget(self.sendButton)
self.bridge = Js2Py()
self.bridge.sent.connect(self.codeFromJs)
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 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 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 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 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 main():
"""Start kernel manager and client, create window, run app event loop"""
app = guisupport.get_app_qt4()
if INPROCESS:
from IPython.qt.inprocess import QtInProcessKernelManager
km = QtInProcessKernelManager()
else:
from IPython.qt.manager import QtKernelManager
km = QtKernelManager()
km.start_kernel()
km.kernel.gui = 'qt4'
kc = km.client()
kc.start_channels()
widget = RichIPythonWidget()
widget.kernel_manager = km
widget.kernel_client = kc
if CLEANSHUTDOWN: # slow exit on CTRL+D
def stop():
kc.stop_channels()
km.shutdown_kernel()
app.exit()
widget.exit_requested.connect(stop)
else: # fast exit on CTRL+D
widget.exit_requested.connect(app.quit)
widget.show()
guisupport.start_event_loop_qt4(app)
def __init__(self, parent):
from logging import getLogger, CRITICAL
logger=getLogger()
silenced=None
for handler in logger.handlers:
if handler.__class__.__name__=='QtHandler':
silenced=handler
old_level=silenced.level
silenced.setLevel(CRITICAL+1)
break
RichIPythonWidget.__init__(self)
self._parent=parent
self.buffer_size=10000 # increase buffer size to show longer outputs
self.set_default_style(colors='linux')
if IPython.__version__<'1.0':
kernelapp=IPythonLocalKernelApp.instance()
kernelapp.initialize()
self.connect_kernel(connection_file=kernelapp.get_connection_file())
else:
kernel_manager=QtInProcessKernelManager(config=self.config, gui='qt4')
kernel_manager.start_kernel()
self.kernel_manager=kernel_manager
self.kernel_client=kernel_manager.client()
self.kernel_client.start_channels()
ip=get_ipython()
# console process exceptions (IPython controlled)
ip.set_custom_exc((Exception,), ip_excepthook_overwrite)
self.namespace=ip.user_ns
self.namespace['IP']=self
self.namespace['app']=QtGui.QApplication.instance()
self.namespace['gui']=parent
self.namespace['plot']=self._plot
if silenced:
silenced.setLevel(old_level)
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 __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, *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 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, **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()
class IPythonView(QtGui.QWidget):
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 stop(self, *args):
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
# Public methods.
# ---------------
def set_data(self, **kwargs):
self.push(**kwargs)
def push(self, **kwargs):
"""Inject variables in the interactive namespace."""
self.shell.push(kwargs)
def run_file(self, file):
"""Execute a Python file in the interactive namespace."""
self.shell.safe_execfile(file, self.shell.user_global_ns)
def run_cell(self, *args, **kwargs):
"""Execute a cell."""
self.shell.run_cell(*args, **kwargs)
class IPythonView(QtGui.QWidget):
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 stop(self, *args):
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
# Public methods.
# ---------------
def set_data(self, **kwargs):
self.push(**kwargs)
def push(self, **kwargs):
"""Inject variables in the interactive namespace."""
self.shell.push(kwargs)
def run_file(self, file):
"""Execute a Python file in the interactive namespace."""
self.shell.safe_execfile(file, self.shell.user_global_ns)
def run_cell(self, *args, **kwargs):
"""Execute a cell."""
self.shell.run_cell(*args, **kwargs)
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
class EmbedIPython(RichIPythonWidget):
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 _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)
class IPythonWidget(RichIPythonWidget):
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 keyPressEvent(self, e):
if e.key() == QtCore.Qt.Key_F2: print "f2"
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 __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, *args, **kwargs):
super(NotebookRunner, self).__init__(*args, **kwargs)
# FrontendWidget protected variables.
self._kernel_manager = None
self._kernel_client = None
self._request_info = {}
self._request_info['execute'] = {}
self._callback_dict = {}
self._result_queue = []
self._final_msg_id = None
self._cell_execute_ids = {}
self._is_active = False
self._executing = False
# Set flag for whether we are connected via localhost.
self._local_kernel = kwargs.get('local_kernel',
NotebookRunner._local_kernel)
self.kernel_manager = KernelManager()
self.kernel_manager.start_kernel()
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels(stdin=False, hb=False)
def __init__(self, *args, **kwargs):
super(NotebookRunner, self).__init__(*args, **kwargs)
# FrontendWidget protected variables.
self._kernel_manager = None
self._kernel_client = None
self._request_info = {}
self._request_info['execute'] = {};
self._callback_dict = {}
self._result_queue = []
self._final_msg_id = None
self._cell_execute_ids = {}
self._is_active = False
self._executing = False
# Set flag for whether we are connected via localhost.
self._local_kernel = kwargs.get('local_kernel',
NotebookRunner._local_kernel)
self.kernel_manager = KernelManager()
self.kernel_manager.start_kernel()
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels(stdin=False, hb=False)
def __init__(self, *args, **kwargs):
super(InProcessRunner, self).__init__(*args, **kwargs)
# FrontendWidget protected variables.
self._kernel_manager = None
self._kernel_client = None
self._request_info = {
'execute': {}
}
self._callback_dict = {}
self._result_queue = []
self._final_msg_id = None
self._cell_execute_ids = {}
self.is_active = False
self.status = STATUS_READY
self._executing = False
# Set flag for whether we are connected via localhost.
self._local_kernel = kwargs.get('local_kernel',
InProcessRunner._local_kernel)
self.kernel_manager = KernelManager()
self.kernel_manager.start_kernel()
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
def main(self):
# Print the ID of the main process
#self.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
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel.shell.push(self.common.__dict__)
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
def stop():
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
#app.exit()
self.control = RichIPythonWidget(banner = self.banner)
self.control.kernel_manager = self.kernel_manager
self.control.kernel_client = self.kernel_client
self.control.exit_requested.connect(stop)
#start widget with certain inputs:
#import pylab, which includes all numpy; import pandas as pd
#second argument is whether the execution is hidden e.g. whether a line is used
#I have turned on hide.
self.control._execute('import pylab as pl; import pandas as pd',True)
def __init__( self, parent ):
super(self.__class__, self).__init__(parent)
# Create an in-process kernel
kernel = InProcessKernel(gui='qt4')
kernel_manager = QtInProcessKernelManager(kernel=kernel)
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
self.kernel_manager = kernel_manager
self.kernel_client = kernel_client
self.kernel = kernel
self.exit_requested.connect(self._stop)
self.show()
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 terminal_widget(**kwargs):
# 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(kwargs)
kernel_client = kernel_manager.client()
kernel_client.start_channels()
control = RichIPythonWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
return control
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, 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 __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, 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, mbus):
super(Main, self).__init__()
self.mbus = mbus
layout = QtWidgets.QVBoxLayout(self)
# ipython console for scripting
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
self._console = IPythonWidget(font_size=9)
self._console.kernel_manager = kernel_manager
self._console.kernel_client = kernel_client
layout.addWidget(self._console)
self.setWindowTitle("Messagebus Ipython Console.")
# push useful imports to console.
self.push(np=np, mbus=mbus,
subscribe=self.subscribe)
def __init__(self, namespace = dict(), **kwargs):
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.user_ns = namespace
self.kernel.shell.push(kwargs)
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.exit_requested.connect(self.exit)
def __init__(self):
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
# Suppress debug messages
self.kernel.log.setLevel(logging.WARNING)
class IPythonConsole(RichIPythonWidget):
def __init__(self, namespace = dict(), **kwargs):
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.user_ns = namespace
self.kernel.shell.push(kwargs)
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.exit_requested.connect(self.exit)
def update_namespace(self, **kwargs):
self.kernel.shell.push(kwargs)
def exit(self, *args):
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
sys.exit()
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 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 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):
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 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)
class SilverIPython(RichIPythonWidget):
''' Wraps an IPython kernel and provides IPython widgets for it '''
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 send_execute(self, *args,**kwargs):
self.kernel_client.execute( *args,**kwargs )
def exit_requested_func(self):
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
qt_app.exit()
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.")
class SilverIPython(RichIPythonWidget):
''' Wraps an IPython kernel and provides IPython widgets for it '''
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 send_execute(self, *args, **kwargs):
self.kernel_client.execute(*args, **kwargs)
def exit_requested_func(self):
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
qt_app.exit()
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)
class IPythonConnection():
def __init__(self):
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
# Suppress debug messages
self.kernel.log.setLevel(logging.WARNING)
def get_widget(self, droplist_completion=True):
completion = 'droplist' if droplist_completion else 'plain'
widget = RichIPythonWidget(gui_completion=completion)
widget.kernel_manager = self.kernel_manager
widget.kernel_client = self.kernel_client
return widget
def push(self, d):
self.kernel.shell.push(d)
def main():
"""Start kernel manager and client, create window, run app event loop,
auto execute some code in user namespace. A minimalist example is shown in
qt_ip_test.py. This is gleaned from ipython.examples.inprocess.embedded_qtconsole
and ipython.IPython.qt.console.qtconsoleapp.new_frontend_master()"""
app = guisupport.get_app_qt4()
if INPROCESS:
from IPython.qt.inprocess import QtInProcessKernelManager
km = QtInProcessKernelManager()
else:
from IPython.qt.manager import QtKernelManager
km = QtKernelManager()
km.start_kernel()
km.kernel.gui = 'qt4'
kc = km.client()
kc.start_channels()
neuropywindow = NeuropyWindow()
ipw = neuropywindow.ipw
config_ipw(ipw)
ipw.exit_requested.connect(app.quit)
ipw.kernel_manager = km
ipw.kernel_client = kc
neuropywindow.show()
# execute some code directly, note the output appears at the system command line:
#kernel.shell.run_cell('print "x=%r, y=%r, z=%r" % (x,y,z)')
# execute some code through the frontend (once the event loop is running).
# The output appears in the ipw. __future__ import in startup.py doesn't seem to work,
# execute directly:
do_later(ipw.execute, "from __future__ import division", hidden=True)
do_later(ipw.execute, "from __future__ import print_function", hidden=True)
do_later(ipw.execute_file, 'startup.py', hidden=True)
do_later(ipw.execute_file, 'globals.py', hidden=True)
guisupport.start_event_loop_qt4(app)
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 __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 __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 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
