def show():
"""
An example of embedding a RichJupyterWidget with an in-process kernel.
We recommend using a kernel in a separate process as the normal option - see
embed_qtconsole.py for more information. In-process kernels are not well
supported.
To run this example:
python3 inprocess_qtconsole.py
"""
#global ipython_widget # Prevent from being garbage collected
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=True)
# kernel = kernel_manager.kernel
# kernel.gui = 'qt5'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
return ipython_widget
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 = QtWidgets.QVBoxLayout(self)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.verticalLayout)
self.verticalLayout.addWidget(self.control)
def start_kernel_manager(self, silo, ui):
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel_manager.kernel.gui = 'qt'
def EulerAngles(name, roll, pitch, yaw, *args, **kwargs):
from signal_logger.rotation_signals import EulerAnglesZyxSignal
return EulerAnglesZyxSignal.from_constant(name, silo.times, roll,
pitch, yaw, *args,
**kwargs)
def clf():
import pylab
pylab.clf()
ui.tab.ui.canvas.canvas.draw()
def plot(signal, *args, **kwargs):
# TODO(scaron): currently plots to the right axis, give choice
signal.plot(*args, **kwargs)
ui.tab.ui.canvas.canvas.draw()
kernel_manager.kernel.shell.push({
'EulerAngles': EulerAngles,
'clf': clf,
'plot': plot,
'pi': numpy.pi,
'silo': silo,
'ui': ui,
})
self.kernel_manager = kernel_manager
def __init__(self, parent=None):
"""
:param parent: specifies the parent widget.
If no parent widget has been specified, it is possible to
exit the interpreter by Ctrl-D.
"""
if sys.executable.endswith('pythonw.exe'):
lpylog = open(tempfile.gettempdir() + '/lpylog.txt', 'w')
sys.stdout = lpylog
sys.stderr = lpylog
RichJupyterWidget.__init__(self, parent)
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel(show_banner=False)
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt'
self.shell = self.kernel.shell
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.kernel.locals = self.kernel.shell.user_ns
def __init__(self,
ctaEngine,
eventEngine,
parent,
customBanner=None,
*args,
**kwargs):
banner = u""
banner += u"\nkTool.datas : 行情数据"
banner += u"\nkTool.parent.spdData : 开仓点分析"
super(QIPythonWidget, self).__init__(banner=banner)
#self.setFixedWidth(420)
if customBanner is not None: self.banner = customBanner
self.font_size = 6
self._display_banner = False
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel_manager.kernel.gui = 'qt'
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 main():
# Print the ID of the main process
print_process_id()
init_asyncio_patch()
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 __init__(self, session, tool_name):
ToolInstance.__init__(self, session, tool_name)
# 'display_name' defaults to class name with spaces inserted
# between lower-then-upper-case characters (therefore "Tool UI"
# in this case), so only override if different name desired
self.display_name = "ChimeraX Python Shell"
from chimerax.ui import MainToolWindow
self.tool_window = MainToolWindow(self)
parent = self.tool_window.ui_area
# UI content code
from ipykernel.ipkernel import IPythonKernel
save_ns = IPythonKernel.user_ns
IPythonKernel.user_ns = {'session': session}
from qtconsole.inprocess import QtInProcessKernelManager
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
from qtconsole.rich_jupyter_widget import RichJupyterWidget
self.shell = RichJupyterWidget(parent)
def_banner = self.shell.banner
self.shell.banner = "{}\nCurrent ChimeraX session available as 'session'.\n\n".format(
def_banner)
self.shell.kernel_manager = kernel_manager
self.shell.kernel_client = kernel_client
IPythonKernel.user_ns = save_ns
from PyQt5.QtWidgets import QHBoxLayout
layout = QHBoxLayout()
layout.addWidget(self.shell)
layout.setStretchFactor(self.shell, 1)
parent.setLayout(layout)
self.tool_window.manage(placement=None)
def createConsole(parent):
"""
disclaimer: this code is not mine. I copied it to get an embedded console
It will be modified at some point to attempt interactability
source: https://stackoverflow.com/a/26676570
:param parent:
:return:
"""
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
kernel_client.namespace = parent
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
layout = QVBoxLayout(parent)
widget = RichJupyterWidget(parent=parent)
layout.addWidget(widget, Qt.AlignRight)
widget.kernel_manager = kernel_manager
widget.kernel_client = kernel_client
widget.exit_requested.connect(stop)
ipython_widget = widget
ipython_widget.show()
kernel.shell.push({'widget': widget, 'kernel': kernel, 'parent': parent})
return {'widget': widget, 'kernel': kernel}
def put_ipy(parent):
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
kernel_client.namespace = parent
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
layout = QtWidgets.QVBoxLayout(parent)
widget = RichJupyterWidget(parent=parent)
layout.addWidget(widget)
widget.kernel_manager = kernel_manager
widget.kernel_client = kernel_client
widget.exit_requested.connect(stop)
ipython_widget = widget
ipython_widget.show()
kernel.shell.push({'widget': widget, 'kernel': kernel, 'parent': parent})
return {'widget': widget, 'kernel': kernel}
def __init__(self, parent=None, custom_banner=None, *args, **kwargs):
if parent is not None:
kwargs["parent"] = parent
super(IPythonWidget, self).__init__(*args, **kwargs)
if custom_banner is not None:
self.banner = custom_banner
self.setWindowTitle(self.banner)
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
# Monkey-patch to workaround issue:
# https://github.com/ipython/ipykernel/issues/370
if (_ipykernel_version_info is not None and
_ipykernel_version_info[0] > 4 and
_ipykernel_version_info[:3] <= (5, 1, 0)):
def _abort_queues(*args, **kwargs):
pass
kernel_manager.kernel._abort_queues = _abort_queues
self.kernel_client = kernel_client = self._kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
self.exit_requested.connect(stop)
def __init__(self, *args):
super(MainWindow, self).__init__(*args)
self.setupUi(self)
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.jupiter_widget.kernel_manager = self.kernel_manager
self.jupiter_widget.kernel_client = self.kernel_client
self.jupiter_widget.reset()
self.reg_view.setColumnCount(2)
self.reg_view.setHorizontalHeaderLabels(['Name', 'Value'])
self.var_view.setColumnCount(4)
self.var_view.setHorizontalHeaderLabels(
['Name', 'Type', 'Address', 'Value'])
# NOTE: icons are from Google Material Design
self.up_button.setIcon(
QIcon(str(APP_ROOT.join('frontend/icon/up.png'))))
self.up_button.setIconSize(QSize(15, 15))
self.up_button.clicked.connect(self.push_up)
self.up_button.setEnabled(False)
self.upto_button.setIcon(
QIcon(str(APP_ROOT.join('frontend/icon/upto.png'))))
self.upto_button.setIconSize(QSize(15, 15))
self.upto_button.clicked.connect(self.push_upto)
self.upto_button.setEnabled(False)
self.down_button.setIcon(
QIcon(str(APP_ROOT.join('frontend/icon/down.png'))))
self.down_button.setIconSize(QSize(15, 15))
self.down_button.clicked.connect(self.push_down)
self.down_button.setEnabled(False)
self.downto_button.setIcon(
QIcon(str(APP_ROOT.join('frontend/icon/downto.png'))))
self.downto_button.setIconSize(QSize(15, 15))
self.downto_button.clicked.connect(self.push_downto)
self.downto_button.setEnabled(False)
self.cg_button.clicked.connect(self.push_callgraph)
self.cg_button.setEnabled(False)
self.info_button.clicked.connect(self.push_info)
self.info_button.setEnabled(False)
self.switch_button.clicked.connect(self.push_switch)
self.switch_button.setEnabled(False)
self.time_slider.setEnabled(False)
self.file_cache = {}
self.file_read_cache = {}
self.callgraph = CallGraphManager()
self.coredump_constraints = []
def add_repl(self,):
"""
Create a new Jupyter REPL session.
"""
self.repl = QtInProcessKernelManager()
self.repl.start_kernel(show_banner=False)
self.view.add_jupyter_repl(self.repl)
def main():
"""Start kernel manager and client, create window, run app event loop"""
app = guisupport.get_app_qt4()
if INPROCESS:
from qtconsole.inprocess import QtInProcessKernelManager
km = QtInProcessKernelManager()
else:
from qtconsole.manager import QtKernelManager
km = QtKernelManager()
km.start_kernel()
km.kernel.gui = 'qt4'
kc = km.client()
kc.start_channels()
widget = RichJupyterWidget()
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, customBanner=None, namespace=dict(), *args, **kwargs):
super(ConsoleWidget, self).__init__(*args, **kwargs)
# if not customBanner is None:
# self.banner = customBanner
self.font_size = 6
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel_manager.kernel.gui = 'qt'
kernel_manager.kernel.shell.banner1 = ""
self.kernel_client = kernel_client = self._kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
QApplication.instance().exit()
self.exit_requested.connect(stop)
self.clear()
self.push_vars(namespace)
def __init__(self, parent=None, *args, **kwargs):
QWidget.__init__(self, parent)
super(ConsoleWidget, self).__init__(*args, **kwargs)
# if customBanner is not None:
# self.banner = customBanner
self.banner = "This is an embedded qtconsole.\nSuggested commands:\n\tvars(emy)\n\n"
# [attr for attr in dir(emy) if not callable(getattr(emy, attr)) and not attr.startswith('__')]
# https://stackoverflow.com/questions/1398022/looping-over-all-member-variables-of-a-class-in-python
self.font_size = 6
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
# kernel_manager.kernel.log.setLevel(logging.CRITICAL) #
kernel_manager.kernel.gui = 'qt'
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_qt().exit()
self.exit_requested.connect(stop)
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 __init__(self, gui,*args, **kwargs):
import ngsolve
super().__init__(*args,**kwargs)
self.gui = gui
self.banner = """NGSolve %s
Developed by Joachim Schoeberl at
2010-xxxx Vienna University of Technology
2006-2010 RWTH Aachen University
1996-2006 Johannes Kepler University Linz
""" % ngsolve.__version__
multikernel_manager = gui.multikernel_manager
if multikernel_manager is not None:
self.kernel_id = multikernel_manager.start_kernel()
self.kernel_manager = multikernel_manager.get_kernel(self.kernel_id)
else:
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel_manager.kernel.gui = 'qt'
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
class dummyioloop():
def call_later(self,a,b):
return
def stop(self):
return
self.kernel_manager.kernel.io_loop = dummyioloop()
def stop():
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
self.exit_requested.connect(stop)
def __init__(self, customBanner=None, *args, **kwargs):
super(ConsoleWidget, self).__init__(*args, **kwargs)
# if customBanner is not None:
"""
if len(sys.argv) > 1:
customBanner = "{}{}{}{}{}".format(
"Check 'ghargs': ",
str(sys.argv[1]),
"\n%run -m src.loadenv\n",
"%run -m src.openstudio_python $osmfile\n",
"%matplotlib inline\n"
)
"""
self.banner = "HYPER-SPACE\n\n"
self.font_size = 6
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel_manager.kernel.gui = 'qt'
self.kernel_client = kernel_client = self._kernel_manager.client()
kernel_client.start_channels()
# test this
t = Test(14)
t1 = Test(26)
D = {"t": t, "ti": t1, "ghargs": sys.argv}
kernel = kernel_manager.kernel
kernel.shell.push(D)
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
guisupport.get_app_qt().exit()
self.exit_requested.connect(stop)
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.
NOTE: Make sure that the Qt v2 API is being used by IPython by running `export
QT_API=pyqt` at the command line before running neuropy, or by adding it to `.bashrc`"""
app = guisupport.get_app_qt4()
if INPROCESS:
from qtconsole.inprocess import QtInProcessKernelManager
km = QtInProcessKernelManager()
else:
from qtconsole.manager import QtKernelManager
km = QtKernelManager()
km.start_kernel()
km.kernel.gui = 'qt4'
kc = km.client()
kc.start_channels()
nw = NeuropyWindow()
ipw = nw.ipw
config_ipw(ipw)
ipw.kernel_manager = km
ipw.kernel_client = kc
ipw.exit_requested.connect(nw.stop)
nw.show()
# execute some code through the frontend (once the event loop is running).
# The output appears in the IPythonWidget (ipw).
do_later(ipw.execute, 'run -i %s' % 'startup.py', hidden=True)
do_later(ipw.execute, 'run -i %s' % 'globals.py', hidden=True)
#guisupport.start_event_loop_qt4(app) # doesn't seem to work in IPy 5.3.0
app.exec_()
def __init__(self, *args, **kwargs):
"""
A constructor matching that of RichJupyterWidget
:param args: Positional arguments passed directly to RichJupyterWidget
:param kwargs: Keyword arguments. The following keywords are understood by this widget:
- startup_code: A code snippet to run on startup.
the rest are passed to RichJupyterWidget
"""
startup_code = kwargs.pop("startup_code", "")
super(InProcessJupyterConsole, self).__init__(*args, **kwargs)
# create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt'
# use a separate thread for execution
shell = kernel.shell
shell.run_code = async_wrapper(shell.run_code, shell)
# attach channels, start kernel and run any startup code
kernel_client = kernel_manager.client()
kernel_client.start_channels()
if startup_code:
shell.ex(startup_code)
self.kernel_manager = kernel_manager
self.kernel_client = kernel_client
# Override python input to raise a QInputDialog.
kernel.raw_input = QAppThreadCall(input_qinputdialog)
def startIPython(self):
""" Create an IPython kernel manager and kernel.
Add modules to its namespace.
"""
# make sure we only log errors and above from ipython
logging.getLogger('ipykernel').setLevel(logging.WARNING)
self.log.debug('IPy activation in thread {0}'.format(
QtCore.QThread.currentThreadId()))
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.namespace = self.kernel.shell.user_ns
self.namespace.update({
'np': np,
'config': self._manager.tree['defined'],
'manager': self._manager
})
if _has_pyqtgraph:
self.namespace['pg'] = pg
self.updateIPythonModuleList()
self.kernel.gui = 'qt4'
self.log.info('IPython has kernel {0}'.format(
self.kernel_manager.has_kernel))
self.log.info('IPython kernel alive {0}'.format(
self.kernel_manager.is_alive()))
self._manager.sigModulesChanged.connect(self.updateIPythonModuleList)
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
mantidplotpath = path.split(
path.dirname(__file__))[0] # It's the directory above this one
# print '[....] mantid plot path: ', mantidplotpath
mantidplotrc = path.join(mantidplotpath, 'mantidplotrc.py')
shell = kernel.shell
shell.run_line_magic('run', mantidplotrc)
# print '[DB...BAUnderstand]: shell 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
self._mainApplication = None
return
def __init__(self, customBanner=None, *args, **kwargs):
super(QIPythonWidget, self).__init__(*args, **kwargs)
if customBanner != None:
self.banner = customBanner
self.setWindowTitle(self.banner)
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():
#clear workspace
msg = QMessageBox(self)
msg.setWindowTitle("Console cleanup")
msg.setText("Do you want to clean the console workspace?")
msg.setStandardButtons(QMessageBox.No | QMessageBox.Yes)
msg.setDefaultButton(QMessageBox.Yes)
ret = msg.exec_()
try:
if ret == QMessageBox.Yes:
self.kernel_manager.kernel.shell.magic('reset -sf')
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
except:
print("Error cleaning console variables")
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
# close widget instead of quitting application
self.close()
self.exit_requested.connect(stop)
def __init__(self, customBanner=None, *args, **kwargs):
super(ConsoleWidget_embed, self).__init__(*args, **kwargs)
if customBanner is not None:
self.banner = customBanner
#self.font_size = 4
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel(show_banner=True)
self.kernel_manager.kernel.gui = 'qt'
self.kernel = self.kernel_manager.kernel
self.kernel_client = self._kernel_manager.client()
self.kernel_client.start_channels()
def _abort_queues(kernel):
pass
self.kernel_manager.kernel._abort_queues = _abort_queues
#self._execute("kernel = %s"%fit, False)
def stop():
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
self.guisupport.get_app_qt().exit()
self.exit_requested.connect(stop)
def start_in_process_kernel():
global kernel_manager, kernel_client
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
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):
super(RichIPythonWidget, self).__init__(parent)
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()
self.kernel.shell.run_cell('%pylab qt')
def __init__(self, parent=None, **kwargs):
super(self.__class__, self).__init__(parent)
self.app = app = guisupport.get_app_qt4()
self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
self.kernel = kernel = kernel_manager.kernel
kernel.gui = 'qt4'
self.kernel_client = kernel_client = kernel_manager.client()
kernel_client.start_channels()
def __init__(self, *args):
super(MainWindow, self).__init__(*args)
self.setupUi(self)
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
self.jupiter_widget.kernel_manager = self.kernel_manager
self.jupiter_widget.kernel_client = self.kernel_client
self.jupiter_widget.reset()
def __init__(self, *args, profile='radar', **kwargs):
super().__init__(*args, **kwargs)
self.manager = manager = QtInProcessKernelManager()
manager.start_kernel()
manager.kernel.log.level = 60 # Disable IPython Logging
client = manager.client(profile=profile)
client.start_channels()
client.log.level = 60
self.kernel_manager = manager
self.kernel_client = client
