def embed_kernel(module=None, local_ns=None, **kwargs):
"""Embed and start an IPython kernel in a given scope.
Parameters
----------
module : ModuleType, optional
The module to load into IPython globals (default: caller)
local_ns : dict, optional
The namespace to load into IPython user namespace (default: caller)
kwargs : various, optional
Further keyword args are relayed to the KernelApp constructor,
allowing configuration of the Kernel. Will only have an effect
on the first embed_kernel call for a given process.
"""
# get the app if it exists, or set it up if it doesn't
if IPKernelApp.initialized():
app = IPKernelApp.instance()
else:
app = IPKernelApp.instance(**kwargs)
app.initialize([])
# load the calling scope if not given
(caller_module, caller_locals) = extract_module_locals(1)
if module is None:
module = caller_module
if local_ns is None:
local_ns = caller_locals
app.kernel.user_module = module
app.kernel.user_ns = local_ns
app.start()
def embed_kernel(module=None, local_ns=None, **kwargs):
"""Embed and start an IPython kernel in a given scope.
If you don't want the kernel to initialize the namespace
from the scope of the surrounding function,
and/or you want to load full IPython configuration,
you probably want `IPython.start_kernel()` instead.
Parameters
----------
module : ModuleType, optional
The module to load into IPython globals (default: caller)
local_ns : dict, optional
The namespace to load into IPython user namespace (default: caller)
kwargs : various, optional
Further keyword args are relayed to the IPKernelApp constructor,
allowing configuration of the Kernel. Will only have an effect
on the first embed_kernel call for a given process.
"""
global embed_kernel_done
if embed_kernel_done:
return
embed_kernel_done = True
(caller_module, caller_locals) = extract_module_locals(1)
if module is None:
module = caller_module
if local_ns is None:
local_ns = caller_locals
# Only import .zmq when we really need it
from .embed import embed_kernel as real_embed_kernel
real_embed_kernel(module=module, local_ns=local_ns, **kwargs)
def embed_kernel(module=None, local_ns=None, **kwargs):
"""Embed and start an IPython kernel in a given scope.
Parameters
----------
module : ModuleType, optional
The module to load into IPython globals (default: caller)
local_ns : dict, optional
The namespace to load into IPython user namespace (default: caller)
kwargs : various, optional
Further keyword args are relayed to the KernelApp constructor,
allowing configuration of the Kernel. Will only have an effect
on the first embed_kernel call for a given process.
"""
# get the app if it exists, or set it up if it doesn't
if IPKernelApp.initialized():
app = IPKernelApp.instance()
else:
app = IPKernelApp.instance(**kwargs)
app.initialize([])
# load the calling scope if not given
(caller_module, caller_locals) = extract_module_locals(1)
if module is None:
module = caller_module
if local_ns is None:
local_ns = caller_locals
app.kernel.user_module = module
app.kernel.user_ns = local_ns
app.start()
def embed_kernel(module=None, local_ns=None, **kwargs):
"""Embed and start an IPython kernel in a given scope.
This code is an exact copy of the IPython.embed.embed_kernel function,
except it uses our IPythonKernelApp subclass of IPKernelApp (so that we can
customize the start-up error message about Ctrl-C not working because of a
technicality in how IPython works)
"""
# get the app if it exists, or set it up if it doesn't
if IPythonKernelApp.initialized():
app = IPythonKernelApp.instance()
else:
app = IPythonKernelApp.instance(**kwargs)
app.initialize([])
# Undo unnecessary sys module mangling from init_sys_modules.
# This would not be necessary if we could prevent it
# in the first place by using a different InteractiveShell
# subclass, as in the regular embed case.
main = app.kernel.shell._orig_sys_modules_main_mod
if main is not None:
sys.modules[app.kernel.shell._orig_sys_modules_main_name] = main
# load the calling scope if not given
(caller_module, caller_locals) = extract_module_locals(1)
if module is None:
module = caller_module
if local_ns is None:
local_ns = caller_locals
app.kernel.user_module = module
app.kernel.user_ns = local_ns
app.shell.set_completer_frame()
app.start()
def embed_kernel(module=None, local_ns=None, **kwargs):
"""Embed and start an IPython kernel in a given scope.
If you don't want the kernel to initialize the namespace
from the scope of the surrounding function,
and/or you want to load full IPython configuration,
you probably want `IPython.start_kernel()` instead.
Parameters
----------
module : ModuleType, optional
The module to load into IPython globals (default: caller)
local_ns : dict, optional
The namespace to load into IPython user namespace (default: caller)
kwargs : various, optional
Further keyword args are relayed to the IPKernelApp constructor,
allowing configuration of the Kernel. Will only have an effect
on the first embed_kernel call for a given process.
"""
(caller_module, caller_locals) = extract_module_locals(1)
if module is None:
module = caller_module
if local_ns is None:
local_ns = caller_locals
# Only import .zmq when we really need it
from ipykernel.embed import embed_kernel as real_embed_kernel
real_embed_kernel(module=module, local_ns=local_ns, **kwargs)
def embed_kernel(module=None, local_ns=None, **kwargs):
"""Based on ipykernel.embed.embed_kernel."""
# get the app if it exists, or set it up if it doesn't
if CoconutKernelApp.initialized():
app = CoconutKernelApp.instance()
else:
app = CoconutKernelApp.instance(**kwargs)
app.initialize([])
# Undo unnecessary sys module mangling from init_sys_modules.
# This would not be necessary if we could prevent it
# in the first place by using a different InteractiveShell
# subclass, as in the regular embed case.
main = app.kernel.shell._orig_sys_modules_main_mod
if main is not None:
sys.modules[app.kernel.shell._orig_sys_modules_main_name] = main
# load the calling scope if not given
(caller_module, caller_locals) = extract_module_locals(1)
if module is None:
module = caller_module
if local_ns is None:
local_ns = caller_locals
app.kernel.user_module = module
app.kernel.user_ns = local_ns
app.shell.set_completer_frame()
app.start()
def apply(self, func, ctx=None, **kwargs):
tmp = dict(globals())
if ctx is None:
_, ctx = extract_module_locals(1)
tmp.update(ctx)
tmp.update(kwargs)
tmp.update(DataOp.__dict__)
res = eval(func, tmp, self.__dict__)
return self.make_new(str(func), y=res)
def embed_kernel(module=None, local_ns=None, **kwargs):
"""Embed and start an IPython kernel in a given scope.
Parameters
----------
module : ModuleType, optional
The module to load into IPython globals (default: caller)
local_ns : dict, optional
The namespace to load into IPython user namespace (default: caller)
kwargs : various, optional
Further keyword args are relayed to the IPKernelApp constructor,
allowing configuration of the Kernel. Will only have an effect
on the first embed_kernel call for a given process.
"""
# get the app if it exists, or set it up if it doesn't
if IPKernelApp.initialized():
app = IPKernelApp.instance()
else:
print "app"
app = IPKernelApp.instance(**kwargs)
#app.initialize([])
# Undo unnecessary sys module mangling from init_sys_modules.
# This would not be necessary if we could prevent it
# in the first place by using a different InteractiveShell
# subclass, as in the regular embed case.
# load the calling scope if not given
(caller_module, caller_locals) = extract_module_locals(1)
if module is None:
module = caller_module
if local_ns is None:
local_ns = caller_locals
print "eventloops.enable_gui"
#ipykernel.eventloops.enable_gui('slicer', kernel=app.kernel)
loop_slicer(app.kernel)
print "initi"
app.initialize(['python', '--gui=slicer'])
app.kernel.user_module = module
app.kernel.user_ns = local_ns
app.shell.set_completer_frame()
#loop_slicer(app.kernel)
main = app.kernel.shell._orig_sys_modules_main_mod
if main is not None:
sys.modules[app.kernel.shell._orig_sys_modules_main_name] = main
print "app.start"
app.start()
return app
def run(self):
if self.run_in_jupyter:
from IPython.lib.guisupport import start_event_loop_qt4
start_event_loop_qt4(app)
return
#if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
if not is_interactive():
if self.ipkernel is not None:
self.ipkernel.user_module, self.ipkernel.user_ns = extract_module_locals(
1)
self.ipkernel.shell.set_completer_frame()
self.ipkernel.start()
else:
QtGui.QApplication.instance().exec_()
def embed_kernel(module=None, local_ns=None, **kwargs):
"""Embed and start an IPython kernel in a given scope.
Parameters
----------
module : ModuleType, optional
The module to load into IPython globals (default: caller)
local_ns : dict, optional
The namespace to load into IPython user namespace (default: caller)
kwargs : various, optional
Further keyword args are relayed to the IPKernelApp constructor,
allowing configuration of the Kernel. Will only have an effect
on the first embed_kernel call for a given process.
"""
# get the app if it exists, or set it up if it doesn't
if IPKernelApp.initialized():
app = IPKernelApp.instance()
else:
app = IPKernelApp.instance(**kwargs)
app.initialize(sys.argv)
# Undo unnecessary sys module mangling from init_sys_modules.
# This would not be necessary if we could prevent it
# in the first place by using a different InteractiveShell
# subclass, as in the regular embed case.
main = app.kernel.shell._orig_sys_modules_main_mod
if main is not None:
sys.modules[app.kernel.shell._orig_sys_modules_main_name] = main
# load the calling scope if not given
(caller_module, caller_locals) = extract_module_locals(1)
if module is None:
module = caller_module
if local_ns is None:
local_ns = caller_locals
app.kernel.user_module = None
app.kernel.user_ns = None
app.shell.set_completer_frame()
if app.poller is not None:
app.poller.start()
app.kernel.start()
return app
def create_kernel(runid=None, do_run_notebook=False, **kwargs):
if runid is None: runid = app.flags.runid
ipkernel = OpaKernelApp.instance()
ipkernel.runid = runid
kwargs.update(current_pid=os.getpid())
if do_run_notebook:
kwargs = dict(kwargs)
kwargs['runid'] = app.flags.runid
threading.Thread(target=run_notebook, kwargs=kwargs).start()
ipkernel.initialize(['python', '--matplotlib=qt'])
par_locals, par_globals = cmisc.get_n2_locals_and_globals()
par_globals = dict(par_globals)
par_globals.update(par_locals)
ipkernel.user_module, _ = extract_module_locals(1)
ipkernel.user_ns = par_globals
ipkernel.shell.set_completer_frame()
time.sleep(1)
ipkernel.start()
from lantz.drivers.keysight.e8364b import E8364B
from A_Lab.Others.LantzAddOns import generateLantzParams
from lantz.log import log_to_screen, DEBUG, INFO, CRITICAL
log_to_screen(DEBUG)
# Create the network analyzer object
na = E8364B('TCPIP0::192.168.1.106::5025::SOCKET')
na.initialize()
#Create the UI
win = NA_Win(network_analyzer = na, autoSave=False, standardPlugins=True)
# Create a console widget, add it to the window and push the current
# current namespace to it
(current_module, current_ns) = extract_module_locals(depth=0)
win.console.push(current_ns)
# ------------------------------------------------------------------------------
# Kill the splash screen to indicate everything is done loading
splash.finish(win)
# Begin the UI event loop
_sys.exit(app.exec_())
